Unity Monobehaviour sınıfı, her bir Unity bileşenin, script dosyasının türetildiği temel sınıftır (base class). Herhangi bir bileşen yaratmak istiyorsanız, bunun direkt veya dolaylı olarak Monobehaviour sınıfından türetilmesi zorunludur. Unity üzerinde 1 defa bile bileşen, component oluşturduysanız Monobehaviour kelimesinin sınıf isminizin yanında yer aldığını görebilirsiniz. Yeni bir script oluşturduğumuzda karşımıza çıkacak olan kod şu şekilde gözükecektir. 

using UnityEngine;

public class NewComponentExample : MonoBehaviour {
    // Çalışan ilk karede çağırılır
    void Start () {

    }
    // Her bir karede çağırılır.
    void Update () {

    }
}

Burada gördüğümüz örnek, direkt olarak türetilmeyi bize gösteriyor. Ancak kendi temel sınıflarınızı oluşturup bundan yeni sınıflar türetmeniz de mümkün. Aşağıdaki kodu incelerseniz, önce toplanabilir şeklinde bir temel sınıf, ardından da meyveler için bir sınıf oluşturuyoruz. Yaptığımız şey de meyveler sınıfını toplanabilir sınıfından türetmek, bu şekilde dolaylı olarak da Monobehaviour sınıfından türetmiş oluyoruz aslında.

using UnityEngine;

public class Collectable : MonoBehaviour {
    public virtual void Collect () {
        Destroy (gameObject);
    }
}

public class Fruit : Collectable {
    public override void Collect () {
        base.Collect ();
        Debug.Log ("Fruit picked up" + gameObject.name);
    }
}

Monobehaviour sınıfını kullandığımızda, yazdığımız script artık oyundaki nesnelerimize (GameObject) bileşen olarak eklenebilir hale geliyor. Bu bileşenler aracılığıyla da farklı işlevleri objelerimize entegre edebiliyor. Az önce verdiğimiz örnek koddaki gibi, istediğimiz objeleri toplanabilir hale getirebiliriz. Bu konuda daha fazla bilgi edinmek için türetme konusunu da içeren “Unity Abstract Class ve Interface Kavramları” yazımızı inceleyebilirsiniz.

Unity Monobehaviour Sınıfı Özellikleri

runInEditMode: Editör üzerinde çalışırken bazı scriptlerin oyunu başlatmadan da çalışmasını isteyebiliriz. Basit bir örnek olarak verebileceğimiz ise, bir objenin sürekli dönmesi olabilir.

using UnityEngine;

public class RunInEditModeExample: MonoBehaviour {

    public float rotateSpeed = 15;
    // Start is called before the first frame update
    void Start () {
        runInEditMode = true;
    }
    // Update is called once per frame
    void Update () {
        transform.Rotate (Vector3.up, rotateSpeed * Time.deltaTime);
    }
}

Bu şekilde runInEditMode komutunu eklediğinizde, genelde yapmak istediğiniz şeye göre yalnızca etkileşime girdiğinizde komutun çalıştığını görebilirsiniz. Tam olarak aynı oyun modunda olduğu gibi çalışmasını isterseniz EditorApplication sınıfındaki Update işlemini inceleyebilirsiniz.

useGUILayout: Kodlar ile ekrana çizdirebileceğimiz GUI arayüz objelerini çizme durumunun es geçilmesini sağlayabileceğimiz komut. False değer atarsak bahsettiğimiz GUI arayüz durumu es geçilecektir. Ancak kodunuz içerisinde OnGUI fonksiyonu bulunuyorsa false değer verseniz bile ekrana çizilecektir. 

using UnityEngine;

public class UseGUILayoutExample: MonoBehaviour {

    // Start is called before the first frame update
    void Start () {
       useGUILayout = false;
    }
}

Unity Monobehaviour Sınıfı Public Fonksiyonları

Unity Monobehaviour Sınıfı public fonksiyonları ister script içerisinde isterseniz de farklı bir script ile erişebildiğimiz fonksiyonlardır. Genel olarak oluşturduğumuz sınıf içerisinde bulunan fonksiyonları farklı şekillerde çalıştırmamızı veya durdurmamızı sağlayan fonksiyonlardır.

CancelInvoke: Invoke veya InvokeRepeating komutuyla çağırılan ve hali hazırda çalışan bütün fonksiyonları veya belirtilen fonksiyonu durdurmamızı sağlayan komuttur. Eğer herhangi bir fonksiyon ismi verilmezse bahsedilen komutlarla çalıştırılan bütün fonksiyonlar durdurulur.

Invoke: Verilen isimdeki fonksiyonu belirtilen süre geçtikten sonra çalıştırmamızı sağlayan komuttur. 

InvokeRepeating: İsmi belirtilen fonksiyonu, belirtilen süre geçtikten sonra, tekrar tekrar çalıştıran fonksiyondur. Ayrıca ne kadar süreye sahip aralıklarla çalıştırılacağını da belirtebiliriz.

IsInvoking: Belirtilen isimdeki fonksiyon Invoke komutuyla çağırılmış ve çalıştırılmayı bekliyor mu durumunu kontrol etmemizi sağlayan komut. Eğer Invoke ile çağrılmış ancak henüz çalıştırılmadıysa true değer döndürecektir.  

using UnityEngine;

public class InvokeExamples : MonoBehaviour {
    //fırlatilacak obje
    public GameObject projectile;

    void Start () {
        // LaunchProjectile 2 saniye sonra başlayacak ve .3 saniye aralıkla devam edecek
        InvokeRepeating ("LaunchProjectile", 2, 0.3F);
        // Launching fonksiyonu 1 saniye sonra başlayacak.
        Invoke ("Launching", 1f);
    }

    void Launching () {
        Debug.Log ("Launching in one second");
    }

    void LaunchProjectile () {
        // projectile isimli objeyi yaratıp 5 birim hızda rastgele yönde velocity değeri atıyoruz.
        GameObject instance = Instantiate (projectile);
        Rigidbody rigidbody = instance.GetComponent<Rigidbody> ();

        rigidbody.velocity = Random.insideUnitSphere * 5;
    }

    void Update () {
        // Sol tık basıldığı anda LaunchProjectile isimli fonksiyona ait Invoke işlemini durduruyoruz.
        if (Input.GetButtonDown ("Fire1")) {
            //eğer hali hazırda çalışıyorsa işlemleri durduralım
            if (IsInvoking ("LaunchProjectile")) {
                CancelInvoke ("LaunchProjectile");
            } else { //eğer çalışan bir fonksiyon yoksa durumdan haberdar ediyoruz.
                Debug.Log ("Nothing to stop");
            }
        }
        //Eğer bütün işlemleri durdurmak isterseniz CancelInvoke() kullanın.
    }
}

StartCoroutine: IEnumarator dönüş tipine sahip olan bir fonksiyonu çağırarak bir Coroutine oluşturmamızı sağlar. 

StopAllCoroutines: Yazıldığı script içerisinde çalışan bütün Coroutine işlemlerini durdurmamızı sağlayan komuttur. 

StopCoroutine: Belirtilen Coroutine işlemini durdurmamızı sağlayan komuttur. 

using System.Collections;
using UnityEngine;

public class CoroutineExamples : MonoBehaviour {
    Coroutine yatayHareket, dikeyHareket;

    public int border = 5;

    //Objenin pozisyonunu sıfırlayıp gerekli hareket fonksiyonlarını StartCoroutine ile çalıştırıyoruz.
    void Start () {
        transform.position = Vector3.zero;
        yatayHareket = StartCoroutine ("Yatay");
        dikeyHareket = StartCoroutine ("Dikey");
    }
    //Sol-sağ fare tuşlarına tıklandıkça Coroutine çalıştıran durduran basit kontroller
    //Dikkat ederseniz hem değişken aracılığıyla hem de fonksiyon ismiyle durdurabilmemiz mümkün.
    void Update () {
        if (Input.GetMouseButtonDown (0)) {
            if (yatayHareket != null) {
                StopCoroutine (yatayHareket);
                yatayHareket = null;
            } else
                yatayHareket = StartCoroutine ("Yatay");
        }
        if (Input.GetMouseButtonDown (1)) {
            if (dikeyHareket != null) {
                StopCoroutine ("Dikey");
                dikeyHareket = null;
            } else
                dikeyHareket = StartCoroutine ("Dikey");
        }

        if (Input.GetKeyDown (KeyCode.Space)) {
            StopAllCoroutines ();
        }
    }
    //Durdurulmadığı sürece y ekseninde belirtilen +- border değeri arasında hareket ettirmeyi sağlayan fonksiyon
    //WaitForEndOfFrame ile her bir karede çalışmasını sağlıyoruz.
    IEnumerator Yatay () {
        Vector3 movement = Vector3.up;
        while (true) {
            if (transform.position.y > border) {
                movement = Vector3.down;
            } else if (transform.position.y < -border) {
                movement = Vector3.up;
            }
            transform.position += movement * Time.deltaTime;
            yield return new WaitForEndOfFrame ();
        }
    }
    //Durdurulmadığı sürece x ekseninde belirtilen +- border değeri arasında hareket ettirmeyi sağlayan fonksiyon
    IEnumerator Dikey () {
        Vector3 movement = Vector3.right;
        while (true) {
            if (transform.position.x > border) {
                movement = Vector3.left;
            } else if (transform.position.x < -border) {
                movement = Vector3.right;
            }
            transform.position += movement * Time.deltaTime;
            yield return new WaitForEndOfFrame ();
        }
    }
}


Coroutine işlemleri ile ilgili daha detaylı bilgi için “Unity Coroutine nedir?” yazımızı inceleyebilirsiniz.

Unity Monobehaviour Sınıfı Mesajlar

Unity Monobehaviour sınıfı mesajları aslında oyun çalışırken var olan döngü içerisinde çeşitli durumlar için farklı işlemler oluşturmamızı sağlayan komutlardır. Görselde göreceğiniz üzere, her bir karede sırayla çalışan farklı işlemler bulunmakta. Resme sağ tıklayıp yeni sekmede açarak tam halini görebilir ve inceleyebilirsiniz.

Yazının devamında belirtilen mesajlar da aslında her bir işlem için oluşturulan fonksiyon taslakları denilebilir. Bu isimlerde fonksiyonlar yarattığımızda, Unity uygulamanın çalışma esnasında bunların hangi sırada veya ne zaman çalışacağını bizim için ayarlayacaktır. Öncelikle en sık kullanacağımız fonksiyonlardan başlayıp sonrasında alfabetik olarak inceleyelim tek tek.

Bu arada belirtmekte fayda var, Unity dokümanını incelediğinizde Network, ağ bağlantılarıyla alakalı fonksiyonlar da bulunuyor. Ancak bunlar yeni sistemde var olmayan ve gelecekte de desteklenmeyecek fonksiyonlar olduğundan bu yazıda onlara yer vermedim.

Start: Obje ilk yaratıldığı anda herhangi bir update fonksiyonu çağrılmaya başlanmadan önce çağrılan fonksiyondur. Yazdığınız script’e dair genel ayarlamaları yapmak için uygundur.

Update: Bileşen aktif olduğu sürece her bir karede çağrılan fonksiyondur.

using UnityEngine;

public class StartUpdateExample : MonoBehaviour {

    Material material;
    //Renderer bileşenine erişmeye çalışıp materyali değişkene alıyoruz, renderer yoksa uyarı veriyoruz.

    private void Start () {
        if (TryGetComponent<Renderer> (out Renderer renderer)) {
            material = renderer.material;
        } else {
            Debug.LogError ("Objede renderer olmalı");
            //eğer editörde çalışıyorsak play moddan çıkış yapıyoruz, diğer durumda uygulamayı kapatıyoruz.
#if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
#else
            Application.Quit ();
#endif
        }
    }

    //Update fonksiyonu her bir karede(frame) çalışacaktır.
    private void Update () {
        //WASD tuşlarına basıldığında objeyi hareket ettirip materyal rengini değiştiriyoruz.
        if (Input.GetKeyDown (KeyCode.A)) {
            transform.position += Vector3.left;
            material.color = Color.black;
        }
        if (Input.GetKeyDown (KeyCode.D)) {
            transform.position += Vector3.right;
            material.color = Color.white;
        }
        if (Input.GetKeyDown (KeyCode.W)) {
            transform.position += Vector3.forward;
            material.color = Color.blue;
        }
        if (Input.GetKeyDown (KeyCode.S)) {
            transform.position += Vector3.back;
            material.color = Color.red;
        }

        //Her karede global Y ekseninde, 1 saniyede 360 derece döndürüyoruz
        transform.Rotate (Vector3.up * 360 * Time.deltaTime);
    }
}

Awake: Awake fonksiyonu oyun çalışırken scriptin yüklendiği ilk anda çağırılan fonksiyondur. 

FixedUpdate: FPS değerinden farklı olarak, sabit zaman aralıklarıyla çalışan fonksiyondur. Update fonksiyonuna benzese de, elde edilen kare sayısından bağımsız olduğundan dolayı, fizik işlemlerini uygulamak amacıyla kullanıma daha uygundur. 

using UnityEngine;

public class AwakeFixedUpdateExample : MonoBehaviour {

    public float jumpForce = 15f;
    Rigidbody rigidbody;

    //Başlangıçta rigidbody değişkenine erişip bir değişkende saklıyoruz.
    void Awake () {
        rigidbody = GetComponent<Rigidbody> ();
    }

    //Space tuşuna basıldığında belirtilen büyüklükte yukarı yönlü bir kuvvet uyguluyoruz. 
    void FixedUpdate () {
        if (Input.GetKeyDown (KeyCode.Space))
            rigidbody.AddForce (Vector3.up * jumpForce, ForceMode.Impulse);
    }
}

Reset: Inspector panelinde bulunan bileşene ait ayarlar menüsünde bulunan Reset butonuna basıldığı anda çağrılır, temelde yaptığı şey bütün değişken değerlerini sıfırlamaktır. Bu değişkenleri kendinize göre ayarlamak için bunu fonksiyonu kullanabilirsiniz. Örneğin oyuncuyu takip edecek bir objede “target” değişkeni Reset ile null hale gelecektir. Player etiketine sahip objeyi bulup atama yapmasını sağlayabilirsiniz. 

using UnityEngine;

public class ResetExample : MonoBehaviour {
    [SerializeField]
    Transform target;

    private void Reset () {
        GameObject player = GameObject.FindGameObjectWithTag ("Player");
        if (player != null)
            target = player.transform;
        else
            Debug.LogWarning ("Sahnede 'Player' tagına sahip obje yok");
    }
}

LateUpdate: Update ve genel Coroutine işlemleri sonrasında, aslında genel olarak yazdığımız oyun mantığının işlendiği her bir karenin sonrasında çağırılan fonksiyondur. Özellikle komutların sıralanması için kullanışlıdır. Örneğin bir kamera script dosyasında, takip edilen objenin Update içerisinde takip ediliyor olması işlemleri doğru yapmamızı engelleyebilir. Update içerisinde takip eden obje hareket eder, işlemlerini bitirir ve kamera objesi de LateUpdate içerisinde sırası gelince gerekli konum ve açı değişikliğini yapar. 

using UnityEngine;

public class LateUpdateExample : MonoBehaviour {
    [SerializeField]
    Transform target;
    Vector3 offset;
    //Hedef ile aradaki mesafeyi alıyoruz
    void Start () {
        offset = target.position - transform.position;
    }
    //Aradaki mesafeyi kullanarak sürekli olarak pozisyon ve rotasyon belirliyoruz
    void LateUpdate () {
        transform.position = target.position - offset;
        transform.rotation = Quaternion.LookRotation (offset);
    }
}

OnDestroy: Bileşenin kendisi veya obje bir şekilde yok edildiğinde (destroy), veya yeni sahneye geçildiğinde, uygulama kapatıldığında da çağırılacak fonksiyondur. 

OnDisable: Obje veya bileşen deaktif hale geldiğinde çağırılan fonksiyondur. Ayrıca herhangi bir şekilde yok edilmeleri durumunda da çağırılacaktır.

OnEnable: Obje aktif hale geldiği anda çağrılan fonksiyondur. 

using UnityEngine;

public class ActiveDeactiveState : MonoBehaviour {
    private void OnDestroy () {
        print (transform.name + " isimli obje yok edildi");
    }
    private void OnDisable () {
        print (transform.name + " isimli obje deaktif hale getirildi");
    }
    private void OnEnable () {
        print (transform.name + " isimli obje aktif hale getirildi");
    }
}

OnAnimatorIK: Animator bileşeni tarafından dahili olan IK sistemi güncellendiğinde otomatik olarak çağırılır. Bu fonksiyon içerisinde IK konumları güncellenebilir ve ne kadar etkili olacakları belirtilebilir.

using System.Collections;
using UnityEngine;

public class OnAnimatorIKExample : MonoBehaviour {
    float leftFootPositionWeight;
    float leftFootRotationWeight;

    Transform leftFootTarget;

    Animator animator;
    //animator bileşenine erişip bir değişkene aktarıyoruz.
    void Start () {
        animator = GetComponent<Animator> ();
    }
    //Sol ayağın pozisyon ve açı değerlerini belirtilen objeyi kopyalayacak şekilde IK aracılığıyla ayarlıyoruz.
    void OnAnimatorIK (int layerIndex) {
        animator.SetIKPositionWeight (AvatarIKGoal.LeftFoot, leftFootPositionWeight);
        animator.SetIKRotationWeight (AvatarIKGoal.LeftFoot, leftFootRotationWeight);
        animator.SetIKPosition (AvatarIKGoal.LeftFoot, leftFootObj.position);
        animator.SetIKRotation (AvatarIKGoal.LeftFoot, leftFootObj.rotation);
    }
}

OnAnimatorMove: Her bir karede çağırılan ve animator objesi aracılığıyla konum bilgisini değiştirmemize olanak veren fonksiyondur. Sıralama olarak OnAnimatorIK fonksiyonundan önce çalışmaktadır.

OnApplicationFocus: Geliştirdiğimiz oyun veya uygulamanın o an aktif mi yoksa arkaplanda mı olduğunu elde etmemizi sağlayan fonksiyondur. True veya false değer elde etmemizi sağlar. Dikkat edilecek bir diğer şey de, unity dokümanlarına göre, Android sistemlerde klavye açılırsa bu fonksiyon false değer alacaktır, yani oyun odak noktası olmayacaktır artık. 

OnApplicationPause : Uygulamanın sistem tarafından durdurulup durdurulmadığını anlamamızı ve ona göre işlemler yapmamızı sağlayan fonksiyondur. OnApplicationFocus ile benzer şekilde çalışıyor gibi görünse de, birbirlerinden farklıdırlar. 

using System.Collections;
using UnityEngine;

public class AppPaused : MonoBehaviour
{
    bool isPaused = false;

    void OnGUI()
    {
        if (isPaused)
            GUI.Label(new Rect(100, 100, 50, 30), "Game paused");
    }

    void OnApplicationFocus(bool hasFocus)
    {
        isPaused = !hasFocus;
    }

    void OnApplicationPause(bool pauseStatus)
    {
        isPaused = pauseStatus;
    }
}

OnApplicationQuit: Uygulamadan çıkış yapılmadan önce işlemler yapmamız için kullanabileceğimiz fonksiyon. Oyuncunun durumunu kayıt gibi işlemleri burada gerçekleştirebiliriz. 

using UnityEngine;

public class LevelManager : MonoBehaviour {
    int currentLevelID;

    private void OnApplicationQuit () {
        //varolan sahne ID değerini alıp playerPrefs üzerinden kayıt alıyoruz.
        PlayerPrefs.SetInt ("LastLevelID", currentLevelID);
        PlayerPrefs.Save ();
    }
}

OnAudioFilterRead: Audio Source üzerinden gelen veriyi manipüle etmemizi sağlayan fonksiyondur. Bu sayede varolan sesleri manipüle edebiliriz veya prosedüral olarak ses yaratabiliriz.

using UnityEngine;

//Bu örnekte prosedural olarak verilen hızda metronom sesi çaldırma işlemi gerçekleştirilmektedir.
[RequireComponent (typeof (AudioSource))]
public class OnAudioFilterReadExample : MonoBehaviour {
    public double bpm = 140.0F;
    public float gain = 0.5F;
    public int signatureHi = 4;
    public int signatureLo = 4;

    private double nextTick = 0.0F;
    private float amp = 0.0F;
    private float phase = 0.0F;
    private double sampleRate = 0.0F;
    private int accent;
    private bool running = false;

    void Start () {
        accent = signatureHi;
        double startTick = AudioSettings.dspTime;
        sampleRate = AudioSettings.outputSampleRate;
        nextTick = startTick * sampleRate;
        running = true;
    }

    /*
    OnAudioFilterRead ile 2 tipte veri geliyor bize. 
    gelen veriler üzerinde oynamalar yaparak istediğimiz hızda bir metronom sesi yaratıyoruz.
    Herhangi bi dosya vermemize gerek kalmıyor.
    */
    void OnAudioFilterRead (float[] data, int channels) {
        if (!running)
            return;

        double samplesPerTick = sampleRate * 60.0F / bpm * 4.0F / signatureLo;
        double sample = AudioSettings.dspTime * sampleRate;
        int dataLen = data.Length / channels;

        int n = 0;
        while (n < dataLen) {
            float x = gain * amp * Mathf.Sin (phase);
            int i = 0;
            while (i < channels) {
                data[n * channels + i] += x;
                i++;
            }
            while (sample + n >= nextTick) {
                nextTick += samplesPerTick;
                amp = 1.0F;
                if (++accent > signatureHi) {
                    accent = 1;
                    amp *= 2.0F;
                }
                Debug.Log ("Tick: " + accent + "/" + signatureHi);
            }
            phase += amp * 0.3F;
            amp *= 0.993F;
            n++;
        }
    }
}

OnBecameInvisible: Scriptin bulunduğu objenin kameranın görüşünde çıktığı an istediğimiz işlemleri gerçekleştirmemizi sağlayan fonksiyondur. 

OnBecameVisible: Scriptin bulunduğu objenin kamerada görünür hale geldiğinde çağırılan fonksiyondur. 

using UnityEngine;

//Sadece kamerada görünür olmadığı durumlarda hedefi takip etme işlemini gerçekleştiren script
public class WeepingAngel : MonoBehaviour {

    [SerializeField]
    Transform target;
    [SerializeField]
    float speed = 15;

    bool canMove = false;

    private void OnBecameVisible () {
        canMove = false;
    }

    private void OnBecameInvisible () {
        canMove = true;
    }
    //hareket edebilir (canMove) değeri false ise  return komutu ile fonksiyonu direkt geri döndürüyoruz, yani return satırı sonrasına geçmiyor işlemler.
    //eğer true değere sahipse, hedef objeye doğru hareket ettiriyoruz.
    private void Update () {
        if (!canMove)
            return;
        //hedef konumundan varolan konumumuzu çıkardığımızda gitmemiz gereken yönü elde ediyoruz. 
        Vector3 direction = target.position - transform.position;
        //Daha sonra elde ettiğimiz vektörü 1 birim uzunluğa sahip olacak şekile getiriyoruz, normalleştiriyoruz.
        direction.Normalize ();
        //ardından direction, yön değerini kullanarak objemizi hareket ettiriyoruz.
        transform.position += direction * speed * Time.deltaTime;
    }
}

OnCollisionEnter: Objenin başka bir objeye temas ettiği, dokunduğu an çalışan fonksiyondur.

OnCollisionExit: Objenin başka bir objeyle temasının bittiği an çağırılan fonksiyondur. 

OnCollisionStay: Objenin başka bir obje ile teması sürdüğü sürece her bir karede çağırılan fonksiyondur. 

using UnityEngine;

public class Fire : MonoBehaviour {
    [SerializeField]
    float damageAmount;

    //temas başladığı anda temasa başlanan objenin hasar alabilir (Damageble) isimli bileşene sahip olup olmadığını kontrol ediyoruz.
    private void OnCollisionEnter (Collision other) {
        other.gameObject.TryGetComponent<Damageble> (out Damageble damageble);
        //Eğer damageble bileşeni varsa, hasar alma efektlerini aktif hale getiriyoruz.
        if (damageble != null) {
            Debug.Log (damageble.damagebleName + "isimli obje yakılmaya başlandı.");
            damageble.ActivateDamageEffect (true);
        }
    }
    //temas bittiği anda temas halindeki objenin hasar alabilir (Damageble) isimli bileşene sahip olup olmadığını kontrol ediyoruz.
    private void OnCollisionExit (Collision other) {
        other.gameObject.TryGetComponent<Damageble> (out Damageble damageble);
        //Eğer damageble bileşeni varsa, hasar alma efektlerini deaktif hale getiriyoruz.
        if (damageble != null) {
            damageble.ActivateDamageEffect (false);
            Debug.Log (damageble.damagebleName + "isimli obje söndü.");
        }
    }
    private void OnCollisionStay (Collision other) {
        other.gameObject.TryGetComponent<Damageble> (out Damageble damageble);
        if (damageble != null) {
            /*Eğer damageble bileşeni varsa, DoDamage fonksiyonu ile hasar uyguluyoruz.
            Aynı update gibi temas olduğu her an, her karede çalıştığı için 
            Time.deltaTime ile hasar değerimizi çarparak, 1 kare geçişinde ne kadarlık hasar
            vermek istediğimizi belirtiyoruz.
            */
            damageble.DoDamage (damageAmount * Time.deltaTime);
            Debug.Log (damageble.damagebleName + "hâlâ yanıyor.");
        }
    }
}

//Damageble isimli bir script yaratıp o dosyaya koymayı unutmayın.
public class Damageble : MonoBehaviour {
    [SerializeField]
    float health = 100;

    public string damagebleName = "Object";

    [SerializeField]
    ParticleSystem damageEffect;

    //Health değerini verilmek istenen hasar kadar azaltıyoruz, ardından 0'ın altına indiyse objeyi yok ediyoruz.
    public void DoDamage (float damageAmount) {
        health -= damageAmount;

        if (health <= 0) {
            Debug.Log (damagebleName + "isimli obje yok oldu");
            Destroy (gameObject);
        } else {
            Debug.Log (damagebleName + "isimli obje " + damageAmount + " kadar hasar aldı, anlık sağlığı" + health);
        }
    }
    //Hasar alma efektlerinin açılıp kapanması için kullanacağımız fonksiyon.
    public void ActivateDamageEffect (bool isActive) {
        if (isActive)
            damageEffect.Play ();
        else
            damageEffect.Stop ();
    }
}

OnCollison fonksiyonlarında dikkat ederseniz Collison tipinde bir değişken belirtmemiz gerekiyor. Bu veri Unity tarafından bize sağlanıyor. Örnekte kullanmadık ancak Collision tipi veriler içerisinde temas etme noktaları, temas edilen objenin collider ve rigidbody gibi bileşenleri bulunmakta. Daha detaylı bilgi elde etmek isterseniz, Unity Collision dokümanına göz atabilirsiniz. Türkçe çevirisi de yakında sitemize eklenecektir 🙂

OnCollisionExit2D: 2D fizik sistemine sahip bir objenin başka bir obje ile teması bittiği an çağırılan fonksiyondur. 

OnCollisionEnter2D: 2D fizik sistemi kullanan objenin başka bir objeye temas ettiği, değdiği an çalışan fonksiyondur. 

OnCollisionStay2D: 2D fizik sistemine sahip bir objenin başka bir obje ile teması sürdüğü sürece her bir karede çağırılan fonksiyondur. 

Yazının öncesinde kullandığımız Collision örneğini de 2D için kullanabilirsiniz. Yalnız dikkat etmeniz gereken şey, objelerde Rigidbody2D ve Collider2D bileşenlerinin olması. Eğer 3d için olan fizik bileşenlerik kullanırsanız 2D fonksiyonları çalışmayacaktır. Ayrıca 2D versiyonlarda Collision yerine Collision2D tipinde değişken kullanıyoruz. Collision2D tipindeki verilerle hangi değişkenlere erişebileceğinizi Unity Collision2D dokümanından inceleyebilirsiniz.

OnControllerColliderHit: Character Controller bileşenine sahip bir objede, Character Controller bileşeniyle gelen collider nesnesinin başka bir nesne ile temas etmesi durumunda çağrılan fonksiyondur.

using UnityEngine;

//Character Controller bileşeni ile hareket ettirilen bir objenin 
//Rigidbody bileşenine sahip olduğu objeleri ittirmesini sağlayan komut.
public class CharacterControllerInteractions : MonoBehaviour {
    public float pushPower = 2.0F;

    void OnControllerColliderHit (ControllerColliderHit hit) {
        //temas edilen objedeki rigidbody bileşenine erişiyoruz.
        Rigidbody body = hit.collider.attachedRigidbody;

        //Temas edilen objede rigidbody yok veya kinematic halde ise return ile hiçbir şey yapmadan dönüyoruz.
        if (body == null || body.isKinematic)
            return;

        // eğer Character Controller aşağı doğru hareket ediyorsa, aşağımızda bulunan objeleri itmek istemeyiz bu yüzden yine geri dönüyoruz. 
        if (hit.moveDirection.y < -0.3f)
            return;

        //Gittiğimiz yöne göre temas ettiğimiz objeye uygulanacak itme için yön belirliyoruz.
        Vector3 pushDir = new Vector3 (hit.moveDirection.x, 0, hit.moveDirection.z);
        //Elde ettiğimiz yön değerini itme kuvveti ile çarparak temas edilen objenin velocity, hareket değerine atıyoruz.
        //Eğer karakterinizin gitmesini istediğiniz belirli bir hız varsa, bunu da çarpım işlemine ekleyebilirsiniz.
        body.velocity = pushDir * pushPower;
    }
}

Rigidbody bileşenine dair daha detaylı bilgi edinmek isterseniz Unity Rigidbody Nedir? yazımıza göz atabilirsiniz.

OnDrawGizmos: Gizmos sınıfı aracılığıyla hareket veya rotation gibi şekilleri gibi görsel şekiller çizmemize imkan sağlayan fonksiyondur. Sizin için önemli olan veya İstediğiniz objeleri daha belirgin hale getirmek için kullanabilirsiniz.

OnDrawGizmosSelected: OnDrawGizmos fonksiyonu gibi çalışır, ancak sadece obje seçili halde ise oluşturulan Gizmo gözükecektir. 

using UnityEngine;

public class OnDrawGizmosExample : MonoBehaviour {

    float areaRadius = 3;

    //Objenin bulunduğu konumda, mavi renkte, 1 birimlik ölçülere sahip bir küp çizdiriyoruz ekranda.
    //Böylece objeyi diğerlerinden ayırt etme ve seçme işlemlerini daha rahat gerçekleştirebiliyoruz.
    private void OnDrawGizmos () {
        Gizmos.color = Color.blue;
        Gizmos.DrawCube (transform.position, Vector3.one);
    }
    //Objeyi seçtiğimiz anda kırmızı renkli, çizgilerden oluşan bir daire çiziyoruz.
    //Örneğin bir kuleniz var ve belirli alana giren düşmanlara saldırabilmesini istiyorsunuz.
    //AreaRadius değişkeni ile oynayarak ne kadarlık alanda saldırı yapabileceğini görsel olarak tespit etmeniz kolaylaşacaktır.
    private void OnDrawGizmosSelected () {
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere (transform.position, areaRadius);
    }
}

OnDrawGizmos fonksiyonlarında, Gizmos sınıfını kullandığımızı farketmişsinizdir. Gizmos sınıfına dair daha detaylı bilgi edinmek için Unity Gizmos Sınıfı yazımızı inceleyebilirsiniz.

OnGUI: Ekran üzerinde arayüz bileşenlerini kodlar aracılığıyla oluşturmamıza imkan veren fonksiyondur. GUI sınıfı aracılığıyla ekrana butonlar, yazılar, görseller yerleştirmek mümkündür. GUI sınıfı hakkında daha fazla bilgi edinmek için Unity GUI dokümanını inceleyebilirsiniz. Kod ile arayüz oluşturmak biraz zahmetli olsa da veya uygulamanızı yayınlarken kullanmanız önerilmese de, geliştirme sürecinde bazı verileri ekranda göstermek, oyuna daha rahat müdahale etmek gibi amaçlarla kendiniz için arayüzler oluşturabilirsiniz.

using UnityEngine;

public class OnGUIExample : MonoBehaviour {
    int yPos = 10, yHeight = 100;

    //Basit bir buton çizdiriyoruz ve tıklandığında ekranda aşağı hareket ettirip metin yazdırıyoruz.
    private void OnGUI () {
        if (GUI.Button (new Rect (10, yPos, 150, yHeight), "Bana Tıkla!!")) {
            print ("Oha bana tıkladın!");
            MoveDown ();
        }
    }
    //ypos değerini butonun yüksekliği kadar arttırdığımızda ekranda kendi boyu kadar yer değiştirmiş olacak.
    void MoveDown () {
        yPos += yHeight;
    }
}

OnJointBreak: Birbirine Joint bileşeni ile bağlı objelerin uygulanan kuvvet sebebiyle birbirinden ayrılması, kopması durumunda çağrılan fonksiyondur. Kopmaya sebep olan kuvveti float cinsinden bize vermektedir.

using UnityEngine;

public class OnJointBreakExample : MonoBehaviour {
    private void OnJointBreak (float breakForce) {
        print (transform.name + " isimli objeye ait joint " + breakForce + " büyüklüğünde kuvvet ile ayrıldı.");
    }
}

OnJointBreak2D: 2D fizik objelerinde birbirine 2D Joint ile bağlanmış objelerin, uygulanan kuvvet sonucu birbirinden ayrılması, kopması durumunda çağrılan fonksiyondur. Joint2D tipinde değeri bize vermektedir.

using UnityEngine;

public class OnJointBreak2DExample : MonoBehaviour {
    private void OnJointBreak2D (Joint2D brokenJoint) {
        print (transform.name + " isimli obje " + brokenJoint.reactionForce +
            " kuvveti ve " + brokenJoint.reactionTorque + " torku ile koptu.");
    }
}

OnMouseEnter: Fare imleci collider bileşenine sahip objenin üzerine getirildiği anda çağrılan fonksiyondur.

OnMouseExit: Fare imleci objenin üzerinden çekildiği an çağrılan fonksiyondur. 

OnMouseOver: Fare imleci objenin üzerinde durduğu süre boyunca, her karede çağrılan fonksiyondur.

using UnityEngine;

public class OnMouseExamples : MonoBehaviour {
    public Renderer rend;

    float colorTimer;

    //Başlangıçta renderer bileşenine erişiyoruz.
    void Start () {
        rend = GetComponent<Renderer> ();
    }

    //Fare ile üzerine geldiğimizde materyal rengini kırmızı yapıyoruz ve colorTimer değerini sıfırlıyoruz
    void OnMouseEnter () {
        rend.material.color = Color.red;
        colorTimer = 0;
    }

    //Fare objenin üzerinde durduğu sürece, rengi kırmızıdan maviye döndürüyoruz.
    //Color.Lerp fonksiyonu iki renk arasında geçiş yapmamızı sağlıyor, 3. değişken olan colorTimer 0 ise ilk değer, 1 ise 2.değer dönüyoruz
    //.5f verirsek de tam ikisinin arasında bir renk değeri elde ederiz. 
    void OnMouseOver () {
        colorTimer += Time.deltaTime;
        rend.material.color = Color.Lerp (Color.red, Color.blue, colorTimer);
    }

    //Fareyi objenin üzerinden çektiğimiz anda tekrar beyaz renge döndürüyoruz.
    void OnMouseExit () {
        rend.material.color = Color.white;
    }
}

OnMouseDown: Collider bileşenine sahip bir objenin üzerine fare ile tıklandığında çağrılan fonksiyondur.

OnMouseDrag: Collider bileşenine sahip bir objenin üzerine fare ile tıklandığında ve tıklama bırakılmadan fare hareket ettirildiği süre boyunca çağrılan fonksiyondur.

OnMouseUp: Fare imleci objenin üzerindeyken fareye tıklama bırakıldığı anda çağrılan fonksiyondur. Ancak dikkat etmekte fayda var, a objesinin üzerindeyken tıklama işlemi yapılıp, daha sonrasında tıklama devam ederken b objesinin üzerine gelip, tıklama bırakılırsa bu fonksiyon yine çalışacaktır. Yani tıklanan obje ile tıklamanın bırakıldığı obje aynı objeler olmak zorunda değildir. 

using UnityEngine;

public class OnMouseInteraction : MonoBehaviour {
    Vector3 startScale;
    Vector3 oldMousePosition;
    //fare ile tıkladığı anda objenin boyutlarını ve farenin tıklama anındaki konumunu değişkenlere saklıyoruz.
    private void OnMouseDown () {
        startScale = transform.localScale;
        oldMousePosition = Input.mousePosition;
    }
    //Tıklama bırakıldığı anda objeyi eski boyutuna döndürüyoruz.
    private void OnMouseUp () {
        transform.localScale = startScale;
    }
    //Fare objeye tıklanılmış halde hareket ettirilirken fare pozisyonunun ne kadar değiştiğini elde edip
    //hareket büyüklüğüne göre objenin boyutunu arttırıyoruz.
    private void OnMouseDrag () {
        Vector3 movement = oldMousePosition - Input.mousePosition;
        transform.localScale += Vector3.one * Time.deltaTime * movement.magnitude;
        oldMousePosition = Input.mousePosition;
    }
}

OnMouseUpAsButton: Fare ile seçili haldeyken tıklanan ve tıklamanın bırakıldığı objenin aynı olması durumunda çalışacaktır. Aynı bir butona basarken olduğu gibi çalıştığından dolayı sonunda  AsButton, button gibi manasında bir ek bulunmaktadır.

OnParticleCollision: Particle System tarafından oluşturulan parçacıkların başka bir objeye temas etmesi durumunda çağrılan fonksiyondur. Hem parçacıklara hem de temas edilen objeye erişip manipüle etmek mümkündür.

OnParticleSystemStopped: Particle System içerisinde bütün parçacıkların yok olduğu ve yeni parçacıkların artık yaratılmayacağı anlarda çağrılan fonksiyondur.

OnParticleTrigger: Particle System içerisinde bulunan Trigger ayarlarına göre parçacıkların belirtilen objelerin içinde geçmesi durumunda çağırılır. .

OnParticleUpdateJobScheduled: Particle System bileşenin kendi içindeki update fonksiyonunda gerekli düzenleme yapıldıktan sonra çağrılan fonksiyondur. Bu fonksiyon sayesinde editör üzerinden yaptığınız ayarlara göre update işleminin gerçekleşmesinin ardından, kod ile parçacıkların pozisyon gibi çeşitli özelliklerine müdahale etmeniz mümkün hale gelir.

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

public class ParticleSystemExamples : MonoBehaviour {
    ParticleSystem ps;

    public float collisionForce = 2;

    private void Start () {
        ps = GetComponent<ParticleSystem> ();
    }
    /*
    OnParticleTrigger fonksiyonunun çalışması için Particle system altında
    Trigger seçeneği aktif olmalı ve ayarları 'callback' şeklinde değiştirmeniz gerekiyor.
    Şu durum için enter ve exit durumlarını 'callback' yapmanız yeterli. 
    'kill' seçeneği seçili olanları ise 'ignore' olarak değiştirmelisiniz.
    Ayrıca hangi objeler ile trigger durumu oluşacağını da listeye ekleyerek belirtmeniz gerekir.
    */
    void OnParticleTrigger () {

        // Trigger objesine giren ve çıkan parçacıkları tutmak için 2 liste oluşturuyoruz.
        List<ParticleSystem.Particle> enter = new List<ParticleSystem.Particle> ();
        List<ParticleSystem.Particle> exit = new List<ParticleSystem.Particle> ();

        // particle system objesi üzerinden trigger etkileşimine giren particle sayılarını elde ediyoruz.
        //bu sayıları bir değişkende tutmamıza gerek yok ama fonksiyonların bunu da döndürdüğünü göstermek istedim
        int numEnter = ps.GetTriggerParticles (ParticleSystemTriggerEventType.Enter, enter);
        int numExit = ps.GetTriggerParticles (ParticleSystemTriggerEventType.Exit, exit);

        /*
        Burada giriş ve çıkış yapan parçacıklara erişiyoruz. 
        Renklerini değiştirip tekrar listedeki değerlerine atama yapıyoruz.
        Daha önceki yorumda dediğim gibi, numEnter yerine direkt enter.Count, exit.Count kullanabilirsiniz.
        */
        for (int i = 0; i < numEnter; i++) {
            ParticleSystem.Particle p = enter[i];
            p.startColor = new Color32 (255, 0, 0, 255);
            enter[i] = p;
        }
        for (int i = 0; i < numExit; i++) {
            ParticleSystem.Particle p = exit[i];
            p.startColor = new Color32 (0, 255, 0, 255);
            exit[i] = p;
        }

        // değiştirdiğimiz parçacıkları tekrar atıyoruz.
        ps.SetTriggerParticles (ParticleSystemTriggerEventType.Enter, enter);
        ps.SetTriggerParticles (ParticleSystemTriggerEventType.Exit, exit);
    }

    /*
    ParticleCollision fonksiyonunun çalışması için particle system altından
    collision seçeneği aktif olmalı ve 'Send Collision Messages' seçeneği aktif halde olmalıdır.
    Ayrıca bu örnek için ben Collision altındaki 'Type' değerini 'World' olarak ayarladım. 
    Böylece dünyadaki trigger özelliği aktif olmayan her bir objeyle collision durumu gerçekleşecek.
     */
    private void OnParticleCollision (GameObject other) {
        //Collision olaylarını bir listede saklıyoruz.
        List<ParticleCollisionEvent> collisionEvents = new List<ParticleCollisionEvent> ();
        int numCollisionEvents = ps.GetCollisionEvents (other, collisionEvents);

        //Çarptığımız objede rigidbody bileşeni olup olmadığını kontrol ediyoruz.
        //Eğer rigidbody varsa çarpışmanın olduğu noktayı ve parçacık hızını kullanarak çarptığımız objeye kuvvet uyguluyoruz.
        if (other.TryGetComponent<Rigidbody> (out Rigidbody rb)) {
            int i = 0;
            while (i < numCollisionEvents) {
                if (rb) {
                    Vector3 pos = collisionEvents[i].intersection;
                    Vector3 force = collisionEvents[i].velocity * collisionForce;
                    rb.AddForceAtPosition (force, pos);
                }
                i++;
            }
        }
    }

    //Yeni bi update particle job oluşturup bunu çalıştırıyoruz.
    void OnParticleUpdateJobScheduled () {
        new UpdateParticlesJob { time = Time.time }.Schedule (ps);
    }

    //Kendi yarattığımız update particle job yapısı. Bu sayede parçacıkların x pozisyonunu zamana göre salınım yapacak şekilde değiştiriyoruz.
    struct UpdateParticlesJob : IJobParticleSystem {
        public float time;

        public void Execute (ParticleSystemJobData particles) {
            var positionsX = particles.positions.x;
            for (int i = 0; i < particles.count; i++) {
                positionsX[i] = Mathf.Sin (time + i);
            }
        }
    }
}

OnPostRender: Kameranın her bir karede render işlemini bitirmesinin ardından çağrılan fonksiyondur.

OnPreCull: Culling işlemi gerçekleşmeden önce çağrılan fonksiyondur.

OnPreRender: Kamera objesinin sahneyi render etme işlemini gerçekleştirmeden önce çağrılan fonksiyondur..

using UnityEngine;

//Kamera objesine eklenmeli
//Kameradan elde edilen görüntüyü yatayda ters hale getiren script
public class FlipRenderHorizontal : MonoBehaviour {
    Camera cam;

    //Camera bileşenine erişiyoruz
    void Start () {
        cam = GetComponent<Camera> ();
    }

    //Cull işlemi yapmadan önce matarix resetlemesi yapıp daha sonrasında matrix'i yatayda ters dönecek hale getiriyoruz.
    void OnPreCull () {
        cam.ResetWorldToCameraMatrix ();
        cam.ResetProjectionMatrix ();
        cam.projectionMatrix = cam.projectionMatrix * Matrix4x4.Scale (new Vector3 (1, -1, 1));
    }

    //PreRender ve PostRender fonksiyonlarında arka yüzlerin algılanma durumunu açıp kapatıyoruz
    //böylece matrix değiştirme sebebiyle yüzeylerin algılanmama, render edilmeme durumlarını önlüyoruz.
    void OnPreRender () {
        GL.invertCulling = true;
    }
    void OnPostRender () {
        GL.invertCulling = false;
    }
}

OnRenderImage: Kamera objesinin sahneyi render etme işleminin tamamlanması ardından çağrılan fonksiyondur. Render sonucu elde edilen görüntüyü manipüle etmeniz mümkündür..

using UnityEngine;
//Script kamera objesinde olmalı
public class OnRenderImageExample : MonoBehaviour {
    /*
    Resim işlemede kullanılacak materyal
    Sprite/Default shader'ı kullanan bir materyal yaratıp beyaz dışında farklı bir renk seçerseniz
    kamera görüntüsünün üzerine o renk eklendiğini göreceksiniz. Eğer sadece renk görünüyorsa, 
    materyal üzerinden rengin alpha değerini azaltın.
    */
    public Material mat;

    void OnRenderImage (RenderTexture src, RenderTexture dest) {
        //Graphics sınıfı yardımıylz, src yani kameranın okuduğu görüntüye
        //istediğimiz materyali uygulayıp dest yani çıktı değerini oluşturuyoruz.
        Graphics.Blit (src, dest, mat);
    }
}

OnRenderObject: Obje ekranda render edildikten sonra çağrılan fonksiyondur. OnPostRender işleminden farklı olarak, kamera objesinde değil, render edilen objelerde çağrılır. Bu sayede her obje için farklı işlemler gerçekleştirmek mümkün olur.

using UnityEngine;

public class OnRenderObjectExample : MonoBehaviour {
    public Mesh mainMesh;
    public Mesh miniMapMesh;

    void OnRenderObject () {
        //Render eden camera ismine bakarak farklı mesh objeleri çizdirmemizi sağlayan fonksiyondur.
        //Minimap kamera oluşturup tepeden bakacak şekilde yerleştirdikten sonra, harita üzerinde
        //ikonlar halinde objeleri göstermemiz mümkündür. Tabii bu oldukça basit bir yöntem.
        if (Camera.current.name == "MiniMapcam") {
            Graphics.DrawMeshNow (miniMapMesh, transform.position, transform.rotation);
        } else {
            Graphics.DrawMeshNow (mainMesh, transform.position, transform.rotation);
        }
    }
}

OnTriggerEnter: İki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme durumunda çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody bileşenine sahip olması gerekir. 

OnTriggerExit: İki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme ve iç içe girmiş olma durumunun bittiği anda çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody bileşenine sahip olması gerekir.

OnTriggerStay: İki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme durumu devam ettiği sürece çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody bileşenine sahip olması gerekir..

using UnityEngine;

public class OnTriggerExamples : MonoBehaviour {

    float speed = 5;

    private void Update () {
        float horizontal = Input.GetAxis ("Horizontal");
        float vertical = Input.GetAxis ("Vertical");
        transform.position += new Vector3 (horizontal, 0, vertical) * speed * Time.deltaTime;
    }
    //SlowArea tagına sahip objeye giriş ve çıkış anında hız değerini değiştiriyoruz
    private void OnTriggerEnter (Collider other) {
        if (other.CompareTag ("SlowArea"))
            speed = 2;
    }
    private void OnTriggerExit (Collider other) {
        if (other.CompareTag ("SlowArea"))
            speed = 5;
    }
    //RotateArea isimli objenin içine girdikten sonra, dışına çıkana kadar objeyi global y ekseninde saniye 90 derece döndürüyoruz.
    private void OnTriggerStay (Collider other) {
        if (other.CompareTag ("RotateArea"))
            transform.Rotate (Vector3.up * 90 * Time.deltaTime);
    }
}

OnTrigger örnekleri için aslında 3 adet küp kullandım. 1 tanesi scriptin atandığı karakter, diğer ikisi de farklı alanları temsil etmesi için. Karakter dışındaki küplerin boyutlarını 5 birimlik hale getirdim ve farklı konumlara yerleştirdim. Ayrıca 2 farklı tipte alan kullandım, birinde hareket hız değeri değişirken, diğerinin içinde bulunduğumuz sürece sürekli bir dönme işlemi gerçekleştiriyoruz. İki alanı algılamak adına da tag, etiket sisteminden yararlandım. Bu fonksiyonlarda bize dönen değer Collider tipinde. Bunlar içerisinde çeşitli fonksiyonlar ve değerlere erişmemiz mümkün. Daha önce görmüş olabileceğiniz Box Collider, Capsule collider gibi bütün collider bileşenlerinin atası, miras aldığı sınıf bu. Genel olarak Collider bileşenleri hakkında bilgi almak için Unity Collider Nedir yazımıza göz atabilirsiniz. Örnekte kullandığımız CompareTag fonksiyonu ise GameObject sınıfından gelen bir fonksiyon, ona dair daha fazla bilgi için Unity GameObject Nedir yazımıza göz atabilirsiniz.

OnTriggerEnter2D: 2D fizik işlemlerinde, iki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme durumunda çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody2D bileşenine sahip olması gerekir.

OnTriggerExit2D: 2D fizik işlemlerinde iki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme ve iç içe girmiş olma durumunun bittiği anda çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody2D bileşenine sahip olması gerekir.

OnTriggerStay2D: 2D fizik işlemlerinde iki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme  durumu devam ettiği sürece çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody2D bileşenine sahip olması gerekir.

2D için olan OnTrigger fonksiyonları da işlevsel olarak aynı şekilde çalışıyor, tabii ki Collider2D ve Rigidbody2D kullanmamız şart. Bi fark olarak da tabii ki 3D için olan Collider değil, Collider2D bileşeni döndürüyor bize. Collider2d hakkında daha fazla bilgi edinmek isterseniz Unity Collider2D dokümanına göz atabilirsiniz, yakında onun da Türkçesi geldiğinde linki buraya ekleriz 🙂

OnValidate: Unity Editör üzerinde değişken yüklendiğinde veya üzerindeki değerler değiştiğinde çağrılan fonksiyondur. Değişkenlerin istediğiniz aralıkta olduğundan emin olmak gibi durumlar için kullanabilirsiniz.

using UnityEngine;
using UnityEngine.UI;
//Bir button yaratıp ona eklediğinizden emin olun. 
[RequireComponent (typeof (Button))]
public class OnValidateExample : MonoBehaviour {

    [SerializeField]
    GameObject prefab;

    //Başlangıçta button bileşenine erişip CreatePrefab fonksiyonunu tıklanma durumunda çalışacak şekilde ekliyoruz.
    private void Start () {
        GetComponent&lt;Button&gt; ().onClick.AddListener (() => {
            CreatePrefab ();
        });
    }
    public void CreatePrefab () {
        Instantiate (prefab);
    }
    //Editor yenilendiğinde veya bu bileşendeki bir değişkeni değiştirdiğimizde OnValidate çalışacak ve button text değerini değiştirecek. 
    private void OnValidate () {
        Text prefabNameText = GetComponentInChildren<Text> ();
        prefabNameText.text = "Create " + prefab.name;
    }
}

OnWillRenderObject: Objenin sahnedeki kameralardan herhangi biri tarafından render edildiği zamanlar, her culling işlemi sırasında çağrılan bir fonksiyondur. Obje için görsel düzenlemeler yapmak amacıyla kullanılabilir. Unity Standard Assets içerisinde bulunan Water.cs dosyasında etkili bir kullanımını görebilirsiniz. Ayrıca bu fonksiyon, kodu eklediğini obje, UI objesi değilse çalışacaktır. Buna da dikkat etmekte fayda var.

Böylece Unity MonoBehaviour Sınıfı yapabileceklerimize örneklerle değinmiş olduk. İsterseniz pek tabii orijinal Unity Monobehaviour dokümanına göz atabilir, örnekleri inceleyebilirsiniz. Faydalı olmuştur umarım, yeni yazılarda görüşmek dileğiyle.

1 Yorum

CEVAP VER

Buraya yorumunuzu ekleyin
Buraya adınızı girin