Unity Fizik Giriş: Rigidbody ve Collider'lar

Giriş: Neden Unity Fizik?

Oyun dünyası, hareket, etkileşim ve gerçekçilik üzerine kuruludur. Bir karakterin yürümesi, bir topun zıplaması, bir arabanın çarpışması... Tüm bu dinamik olaylar, güçlü bir fizik motoru sayesinde hayat bulur. Unity'nin yerleşik fizik motoru, geliştiricilere oyunlarına bu gerçekçi boyutu katmaları için esnek ve güçlü araçlar sunar. Bu makalede, Unity Fizik Sistemi'nin iki temel yapı taşı olan

Rigidbody

Collider

bileşenlerini derinlemesine inceleyeceğiz. Bu bileşenlerin ne işe yaradığını, nasıl kullanıldığını ve oyunlarınızda dinamik ve etkileşimli deneyimler yaratmak için nasıl bir araya getirilebileceğini öğreneceksiniz.

Rigidbody Nedir ve Nasıl Kullanılır?

Bir

Rigidbody

(Katı Cisim) bileşeni, bir

GameObject

'in Unity'nin fizik motorunun kontrolü altına girmesini sağlar. Yani, bu bileşeni eklediğiniz bir nesne, yerçekimi, kuvvet, tork ve çarpışmalar gibi gerçek dünya fizik kurallarına tabi olur. Bir topun düşmesi, bir karakterin zıplaması veya bir aracın ivmelenmesi gibi tüm fiziksel hareketler

Rigidbody

sayesinde mümkün olur.

Rigidbody Bileşeninin Temel Özellikleri

Mass (Kütle): Nesnenin ağırlığını belirler. Daha yüksek kütleli nesneler, aynı kuvvete maruz kaldıklarında daha yavaş hızlanırlar.
Drag (Sürtünme): Nesnenin doğrusal hareketine karşı uygulanan hava veya ortam sürtünmesini temsil eder. Yüksek değerler, nesnenin daha hızlı yavaşlamasına neden olur.
Angular Drag (Açısal Sürtünme): Nesnenin dönme hareketine karşı uygulanan sürtünmedir.
Use Gravity (Yerçekimi Kullan): İşaretliyse, nesneye dünya yerçekimi uygulanır. Platformer oyunlarında veya düşen nesnelerde bu genellikle aktif olmalıdır.
Is Kinematic (Kinematik mi): Bu özellik çok önemlidir. İşaretliyse,
```
Rigidbody
```
artık fizik motoru tarafından değil, doğrudan
```
transform
```
bileşeni veya
```
Rigidbody.MovePosition()
```
gibi metotlar aracılığıyla kod tarafından kontrol edilir. Fiziksel kuvvetlere tepki vermez, ancak yine de çarpışma algılaması yapabilir. Genellikle hareketli platformlar veya kapılar gibi, fizik kurallarına göre değil, belirli bir yol boyunca hareket etmesini istediğimiz nesneler için kullanılır.
Constraints (Kısıtlamalar): Nesnenin belirli eksenlerde hareket etmesini veya dönmesini kısıtlamanıza olanak tanır. Örneğin, bir karakterin havada dönmesini engellemek için X ve Z eksenlerindeki dönmeleri dondurabilirsiniz.

Rigidbody Kontrolü için C# Kodları

Bir

Rigidbody

nesnesine kod aracılığıyla kuvvet uygulamak veya hızını değiştirmek için çeşitli metotlar bulunur. Fiziksel işlemlerin

FixedUpdate()

içinde yapılması önerilir, çünkü bu fonksiyon fizik motorunun sabit zaman adımında çalışır.

using UnityEngine;

public class RigidbodyKontrol : MonoBehaviour
{
    public Rigidbody rb;
    public float hareketGucu = 10f;
    public float ziplamaGucu = 5f;

    void Start()
    {
        // Rigidbody bileşenini al
        rb = GetComponent<Rigidbody>();
    }

    void FixedUpdate()
    {
        // İleriye doğru kuvvet uygulama
        if (Input.GetKey(KeyCode.W))
        {
            rb.AddForce(transform.forward * hareketGucu, ForceMode.Acceleration);
        }
        // Zıplama kuvveti uygulama
        if (Input.GetKeyDown(KeyCode.Space))
        {
            rb.AddForce(Vector3.up * ziplamaGucu, ForceMode.Impulse);
        }
    }
}

Yukarıdaki kodda

ForceMode

parametresi önemlidir:

```
Force
```
: Kütle göz önünde bulundurularak sürekli bir kuvvet uygular.
```
Acceleration
```
: Kütle göz önünde bulundurulmadan sürekli bir ivme uygular.
```
Impulse
```
: Kütle göz önünde bulundurularak anlık bir kuvvet uygular (örn: zıplama).
```
VelocityChange
```
: Kütle göz önünde bulundurulmadan anlık bir hız değişimi uygular.

Collider Nedir ve Çeşitleri Nelerdir?

Collider

(Çarpıştırıcı) bileşeni, bir oyun nesnesinin fiziksel şeklini tanımlar ve diğer nesnelerle çarpışmaları veya temasları algılamasını sağlar. Görsel olarak karmaşık bir modeliniz olsa bile, fizik motoru çarpışmaları

Collider

'ın basit şekline göre hesaplar. Bir

Rigidbody

ile birlikte kullanıldığında nesne fiziksel olarak çarpışır;

Rigidbody

olmadan kullanıldığında ise (statik nesnelerde) diğer

Rigidbody

'li nesnelerle çarpışabilir ancak kendisi fiziksel olarak hareket etmez.

Collider Çeşitleri ve Kullanım Alanları

Box Collider (Kutu Çarpıştırıcı): En basit ve en performanslı
```
Collider
```
türüdür. Küp veya dikdörtgen prizma şeklindeki nesneler için idealdir.
Sphere Collider (Küre Çarpıştırıcı): Küre şeklindeki nesneler (toplar, mermiler) için kullanılır. Performansı oldukça iyidir.
Capsule Collider (Kapsül Çarpıştırıcı): Genellikle karakterler için kullanılır, zira ayakta duran bir insan figürünü iyi temsil eder ve yuvarlak hatları sayesinde köşelere takılma olasılığı daha düşüktür. Performansı iyidir.
Mesh Collider (Ağ Çarpıştırıcı): Bir modelin tam 3D şeklini kullanır. En karmaşık ve performans açısından en pahalı
```
Collider
```
türüdür. Genellikle statik (hareketsiz) ve karmaşık arazi veya detaylı mimari modeller için kullanılır. Hareketli
```
Mesh Collider
```
'lar çok daha maliyetlidir ve
```
Convex
```
seçeneği işaretlenmelidir.
Terrain Collider (Arazi Çarpıştırıcı): Sadece Unity'nin
```
Terrain
```
(Arazi) objeleri için kullanılır ve arazinin karmaşık yüzeyine uygun bir
```
Collider
```
sağlar.

Trigger Collider'lar ve Çarpışma Tespiti

Bir

Collider

bileşenindeki

Is Trigger

seçeneğini işaretlerseniz, bu

Collider

artık fiziksel bir engel oluşturmaz. Bunun yerine, bir nesne bu

Collider

'ın içine girdiğinde veya çıktığında olayları tetikler. Bu, kapıların otomatik açılması, mermi isabeti tespiti veya toplama alanları oluşturmak için idealdir.

Çarpışma veya tetikleme olaylarını yakalamak için C# scriptlerinizde özel fonksiyonlar kullanırsınız:

```
OnCollisionEnter(Collision collision)
```
: İki nesne fiziksel olarak çarpıştığında bir kez tetiklenir. En az bir nesnede
```
Rigidbody
```
olmalıdır.
```
OnCollisionStay(Collision collision)
```
: İki nesne çarpışmaya devam ettiği sürece her fizik adımında tetiklenir.
```
OnCollisionExit(Collision collision)
```
: İki nesne çarpışmayı bitirip ayrıldığında bir kez tetiklenir.
```
OnTriggerEnter(Collider other)
```
: Bir
```
Collider
```
(
```
Is Trigger
```
işaretli) içine başka bir
```
Collider
```
girdiğinde bir kez tetiklenir. En az bir nesnede
```
Rigidbody
```
olmalıdır.
```
OnTriggerStay(Collider other)
```
: Bir
```
Collider
```
(
```
Is Trigger
```
işaretli) içinde başka bir
```
Collider
```
kaldığı sürece her fizik adımında tetiklenir.
```
OnTriggerExit(Collider other)
```
: Bir
```
Collider
```
(
```
Is Trigger
```
işaretli) içinden başka bir
```
Collider
```
çıktığında bir kez tetiklenir.

using UnityEngine;

public class CarpismaAlgilayici : MonoBehaviour
{
    void OnCollisionEnter(Collision collision)
    {
        Debug.Log("Fiziksel çarpışma oldu: " + collision.gameObject.name);
        // Çarpışan nesnenin Rigidbody'sine erişim: collision.rigidbody
        // Çarpışma noktaları: collision.contacts
    }

    void OnTriggerEnter(Collider other)
    {
        Debug.Log("Trigger tetiklendi: " + other.gameObject.name);
        if (other.CompareTag("ToplanabilirOge"))
        {
            Debug.Log(other.gameObject.name + " toplandı!");
            Destroy(other.gameObject);
        }
    }
}

Pratik İpuçları

Unity Fizik Sistemi'ni etkin bir şekilde kullanmak için bazı pratik ipuçları:

1. Katmanlar (Layers) ve Fizik Etkileşim Matrisi

Unity, hangi katmanlardaki nesnelerin birbiriyle çarpışacağını kontrol etmenizi sağlar.

Edit > Project Settings > Physics

(veya 2D oyunlar için

Physics 2D

) menüsünde bulunan "Layer Collision Matrix" (Katman Çarpışma Matrisi) ile bu ayarları yapabilirsiniz. Bu, gereksiz çarpışma hesaplamalarını önleyerek performansı artırır ve oyununuzdaki etkileşimleri daha hassas bir şekilde yönetmenizi sağlar. Örneğin, oyuncu mermilerinin düşman mermileriyle çarpışmasını istemiyorsanız, bu katmanları matriste devre dışı bırakabilirsiniz.

2. Rigidbody'siz Nesnelerle Çarpışma Tespiti

Bir nesnenin

Rigidbody

bileşeni olmasa bile (yani statik bir nesne ise), üzerinde bir

Collider

bulunabilir. Dinamik bir

Rigidbody

nesnesi, bu statik

Collider

ile çarpışabilir ve

OnCollisionEnter

gibi olayları tetikleyebilir. Ancak, iki statik

Collider

(yani ikisinde de

Rigidbody

olmayan) birbirini asla algılamaz veya fiziksel olarak etkileşime girmez. Trigger olayları için de aynı kural geçerlidir: en az bir

Collider

üzerinde

Rigidbody

bulunmalıdır.

3. Fizik Materyalleri (Physics Materials)

Fizik materyalleri, nesnelerin yüzeylerinin sürtünme (

Friction

) ve zıplama (

Bounciness

) gibi özelliklerini tanımlamanızı sağlar. Bir

Collider

bileşenine bir fizik materyali atayarak, nesnenin diğer yüzeylerle nasıl etkileşime gireceğini belirleyebilirsiniz. Örneğin, buz için düşük sürtünme ve düşük zıplama, bir lastik top için yüksek zıplama değerleri atayabilirsiniz. Bunlar,

Project

penceresinde sağ tıklayıp

Create > Physics Material

seçilerek oluşturulur.

Yaygın Hatalar ve Çözümleri

1. Rigidbody Olmadan Çarpışma Beklemek

Hata: İki nesnenin çarpışmasını bekliyorsunuz, ancak her ikisinde de sadece

Collider

var ve

Rigidbody

yok.

Çözüm: Çarpışma algılaması ve fiziksel etkileşimler için, etkileşimde bulunan nesnelerden en az birinde

Rigidbody

bileşeni bulunmalıdır. Genellikle hareketli olan nesneye

Rigidbody

eklenir.

2. isKinematic'i Yanlış Anlamak

Hata: Bir nesnenin

Rigidbody

'si var ve

isKinematic

işaretli, ancak ona

AddForce()

ile kuvvet uygulamaya çalışıyorsunuz veya fiziksel etkileşimler bekliyorsunuz.

Çözüm:

isKinematic

işaretli bir

Rigidbody

, fizik motoru tarafından değil, doğrudan

transform.position

veya

transform.Translate()

gibi metotlarla kod aracılığıyla kontrol edilir. Fiziksel kuvvetlere tepki vermesini veya yerçekiminden etkilenmesini istiyorsanız,

isKinematic

seçeneğinin işaretini kaldırın. Kinematik nesneleri hareket ettirmek için

Rigidbody.MovePosition()

Rigidbody.MoveRotation()

kullanmak, fizik motoruyla daha uyumlu bir yaklaşımdır.

3. Performans Sorunları (Çok Fazla MeshCollider)

Hata: Sahnenizde çok sayıda karmaşık

Mesh Collider

kullanmak, özellikle hareketli nesnelerde.

Çözüm:

Mesh Collider

'lar, karmaşık şekilleri temsil etmek için kullanışlıdır ancak performans maliyetleri yüksektir. Mümkün olduğunca

Box Collider

Sphere Collider

Capsule Collider

gibi daha basit

Collider

tiplerini kullanmaya çalışın. Karmaşık modeller için

Mesh Collider

kullanıyorsanız,

Convex

seçeneğini işaretleyin (bu, şekli basitleştirir ve daha performanslı hale getirir) ve mümkünse onları statik nesneler üzerinde tutun. Hareketli

Mesh Collider

'lardan kaçının veya çok dikkatli kullanın.

Performans ve Optimizasyon Notları

Oyununuzun akıcı çalışması için Unity Fizik Sistemi'ni optimize etmek kritik öneme sahiptir:

Basit Collider'lar Tercih Edin: Yukarıda belirtildiği gibi,
```
Box
```
,
```
Sphere
```
ve
```
Capsule Collider
```
'lar,
```
Mesh Collider
```
'lara göre çok daha hızlı hesaplanır. Performansı etkilemeden modelinizin fiziksel sınırlarını temsil etmek için bunları kullanmaya özen gösterin.
Fizik Etkileşim Matrisi Kullanın:
```
Project Settings > Physics
```
altındaki katman çarpışma matrisini akıllıca kullanarak, hangi nesnelerin birbiriyle etkileşime gireceğini sınırlayın. Bu, özellikle kalabalık sahnelerde gereksiz çarpışma kontrollerini ortadan kaldırarak performansı önemli ölçüde artırabilir.
Fixed Timestep Ayarı:
```
Edit > Project Settings > Time
```
altındaki
```
Fixed Timestep
```
değeri, fizik hesaplamalarının ne sıklıkta yapılacağını belirler. Varsayılan değer 0.02 (saniyede 50 fizik güncellemesi) çoğu oyun için iyi bir denge sağlar. Daha düşük bir değer (örn: 0.01), daha doğru ancak daha pahalı fizik hesaplamaları anlamına gelir. Oyununuzun türüne ve gereksinimlerine göre bu değeri ayarlayabilirsiniz.
Uyku (Sleeping) Mekanizması: Unity, hareket etmeyen
```
Rigidbody
```
'leri otomatik olarak uyku moduna sokar ve onlara yönelik fizik hesaplamalarını durdurur. Bu, performans için harika bir özelliktir. Nesneleri gereksiz yere sürekli hareket ettirmemeye çalışın (örn:
```
transform.position
```
ile sürekli hareket ettirilen
```
isKinematic
```
olmayan
```
Rigidbody
```
'ler uykuda kalamaz ve sürekli hesaplanır).

Sonuç

Unity Fizik Sistemi, oyunlarınıza dinamik ve gerçekçi bir boyut katmak için vazgeçilmez bir araçtır.

Rigidbody

Collider

bileşenlerini doğru bir şekilde anlamak ve kullanmak, sadece daha etkileşimli ve inandırıcı oyun mekanikleri oluşturmakla kalmaz, aynı zamanda oyununuzun performansını da optimize etmenizi sağlar. Bu makaledeki bilgiler ve ipuçları, Unity'de fizik tabanlı oyunlar geliştirme yolculuğunuzda size sağlam bir temel sunacaktır. Deneyerek ve pratik yaparak bu güçlü araçları ustaca kullanmaya başlayabilirsiniz. Başarılar dileriz!