Unity Time Sınıfı ve Kullanımı Örnekleri
Unity Time sınıfı, oyun zamanını yönetmek için kullanılan bir sınıftır. Time sınıfı, oyunun süresini ölçmek, zaman aralıklarını belirlemek ve geçen zamanla ilgili hesaplamalar yapmak için kullanılabilir.
Time sınıfı, genellikle oyun süreci boyunca değişen zaman bilgilerini tutmak için kullanılır. Bu sınıf sayesinde, oyun zamanıyla ilgili çeşitli işlemler yapabilirsiniz. Örneğin, oyununuzda bir düşmanın her saldırı yapması için belirli bir süre beklemesi gerektiğinde, Time sınıfını kullanarak bu bekleme süresini hesaplayabilirsiniz.
Time sınıfında en sık kullanılan özelliklerden biri Time.deltaTime’dir. Bu özellik, son kare ve şu anki kare arasındaki zaman farkını tutar ve böylece oyunu sabit bir hızda çalıştırmak için kullanılabilir. Bu özellik, özellikle animasyonların ve nesnelerin hareket ettiği durumlarda faydalıdır.
Ayrıca, Time.timeScale özelliği, oyun zamanını hızlandırmak veya yavaşlatmak için kullanılabilir. Örneğin, bir oyunun hızlandırılmış bir bölümünde, Time.timeScale özelliği kullanılarak oyun hızı arttırılabilir.
Özetle, Time sınıfı, oyun zamanıyla ilgili işlemler yapmak için kullanılır ve Time.deltaTime, Time.timeScale gibi özellikleri ile oyunun zamanını yönetmek ve ölçmek için faydalıdır.
Static Properties
captureDeltaTime Özelliği
Unity Time sınıfında yer alan captureDeltaTime static properties, Unity Editor içerisinde, düzenleme modunda yer alan frame yakalama işlemlerinde kullanılır. Bu özellik, her bir karede geçen süreyi hesaplar ve bunu saklar.
captureDeltaTime özelliği, varsayılan olarak sıfır değerindedir. Ancak Unity Editor’da frame yakalama işlemi yapıldığında, bu özellik son yakalanan karedeki geçen süreyi tutar ve sonraki kare için bu süreyi kullanır. Böylece, sonraki kareyi yakalamadan önce geçen süreyi hesaplamak için ekstra bir işlem yapılmasına gerek kalmaz.
Bu özellik özellikle, oyun geliştirirken animasyonlar ve hareketler gibi ince ayar gerektiren durumlarda kullanışlıdır. Örneğin, bir oyun karakterinin koşu animasyonunun hızı, hareket hızına bağlı olarak ayarlanabilir. Bu durumda, captureDeltaTime özelliği, her karede geçen süreyi hesaplayarak animasyon hızını doğru bir şekilde ayarlamak için kullanılabilir.
Örneğin, bir oyun geliştiriyorsunuz ve oyun karakterinizin koşu animasyonunu ayarlamanız gerekiyor. Animasyon hızını doğru bir şekilde ayarlamak için, karakterin hızını kullanarak animasyon hızını hesaplamak istiyorsunuz.
Bu durumda, captureDeltaTime özelliğini kullanarak her karede geçen süreyi hesaplayabilirsiniz. Karakterin hareket hızı, Time.deltaTime ile çarpılarak, her karede karakterin ne kadar hareket ettiği hesaplanabilir. Bu değer, captureDeltaTime ile çarpılarak, her karede geçen süreyi hesaplamak için kullanılabilir.
Örneğin, aşağıdaki kod bloğu, karakterin hareket hızını hesaplar ve animasyon hızını ayarlamak için captureDeltaTime özelliğini kullanır:
void Update()
{
float characterSpeed = 5.0f; // Karakterin hareket hızı
float animationSpeed = characterSpeed * Time.deltaTime / Time.captureDeltaTime; // Animasyon hızı
// Animasyon hızını ayarla
animator.SetFloat("Speed", animationSpeed);
} Bu kod bloğu, karakterin hareket hızını 5.0f olarak ayarlar ve her karede geçen süreyi captureDeltaTime ile hesaplar. Animasyon hızını, karakterin hareket hızının geçen süreye bölünmesi ile hesaplar ve animasyon hızını ayarlamak için Unity animator sisteminin SetFloat() fonksiyonunu kullanır.
captureFramerate Özelliği
Unity Time sınıfının captureFramerate static property’si, uygulamanın çalışma hızını kontrol etmek için kullanılır. Bu özellik, uygulamanın belirli bir kare hızında çalışmasını sağlamak için kullanılır.
captureFramerate, uygulamanın maksimum kare hızını ayarlamak için kullanılır. Bu özellik, uygulamanın çalışma hızını kontrol etmek için kullanılır ve özellikle performans sorunları yaşadığınızda faydalıdır.
Örneğin, captureFramerate değerini 60 olarak ayarlarsanız, uygulama maksimum 60 kare/sn hızında çalışacaktır. Eğer uygulamanın belirli bir kare hızında çalışması gerekiyorsa, bu özellik kullanılarak istenen kare hızına sabitlenebilir.
Aşağıdaki örnekte, captureFramerate özelliği kullanılarak uygulamanın maksimum kare hızı ayarlanmıştır:
void Start()
{
Time.captureFramerate = 60; // uygulamanın maksimum kare hızı 60 olarak ayarlandı
} Bu örnek, uygulamanın maksimum kare hızını 60 olarak ayarlar ve uygulama bu kare hızında çalışır. Bu, uygulamanın daha düşük performanslı cihazlarda daha sorunsuz çalışmasını sağlayabilir.
deltaTime Özelliği
Unity Time sınıfı, Unity oyun motorunda zamanla ilgili işlemleri gerçekleştirmek için kullanılan bir sınıftır. deltaTime ise, son iki kare arasındaki süreyi (farkı) sağlayan ve zaman tabanlı animasyon, fizik ve diğer zaman tabanlı işlemler için kullanılan bir özelliktir.
deltaTime, her kare arasındaki zaman farkını belirler. Bu, örneğin her karede objelerin konumlarını güncelleyerek oyun sahnesinde hareketi sağlamak gibi işlemlerde kullanılabilir. Örneğin, bir topu havada hareket ettirirken, her karede topun hareketini hesaplamak ve güncellemek için deltaTime kullanabilirsiniz.
Aşağıdaki örnek, topu hareket ettirmek için deltaTime kullanır:
public float speed = 5f;
private Rigidbody rb;
void Start () {
rb = GetComponent<Rigidbody>();
}
void FixedUpdate () {
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(moveHorizontal, 0.0f, moveVertical);
rb.AddForce(movement * speed * Time.deltaTime);
} Bu örnekte, her karede topun hareketini hesaplamak için deltaTime kullanılmaktadır. Topun hızını (speed) deltaTime ile çarparak, her karede objenin konumunu günceller ve topu hareket ettirir.
fixedDeltaTime Özelliği
Unity’de, Time sınıfı, zamanla ilgili birçok özellik ve yöntem sağlayan bir statik sınıftır. Bu sınıf, oyun nesnelerinin hareketi, animasyonları, fizik simulasyonları vb. gibi süreçleri kontrol etmek için kullanılır. fixedDeltaTime özelliği de Time sınıfının bir parçasıdır ve sabit zaman aralığı sağlar.
fixedDeltaTime, oyun motorundaki sabit bir zaman aralığını temsil eder. Bu, fizik simulasyonlarının ne kadar sık güncelleneceğini kontrol etmek için kullanılır. Fizik motoru, simülasyonları her çerçeve için birkaç kez günceller ve bu işlem arasındaki süreyi belirleyen değer fixedDeltaTime’dur. Bu, her çerçeve için aynı olacak şekilde ayarlanır ve değiştirilemez.
Örneğin, bir topun hareketini simüle etmek istiyorsanız, topun Rigidbody bileşenine eklediğiniz bir güç değeri kullanarak topu hareket ettirirsiniz. Ancak, topun hızı ve konumu fizik motoru tarafından hesaplandığından, bu güç değeri sabit bir zaman aralığında (yani fixedDeltaTime) uygulanır. Bu, topun hızı ve konumunun doğru bir şekilde hesaplanmasını sağlar.
Aşağıdaki örnek, bir topun sabit bir hızla hareket etmesini gösterir ve bu hareket fixedDeltaTime kullanılarak simüle edilir:
public class BallController : MonoBehaviour
{
public float speed = 5f; // topun hareket hızı
private Rigidbody rb;
void Start()
{
rb = GetComponent<Rigidbody>();
}
void FixedUpdate()
{
// topu sabit bir hızla hareket ettir
Vector3 movement = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
rb.AddForce(movement * speed * Time.fixedDeltaTime);
}
} Bu kodda, FixedUpdate() metodu, topun hareketini simüle etmek için kullanılır ve AddForce() yöntemi, topa bir kuvvet uygular. Kuvvet, movement vektörü ile speed çarpılarak hesaplanır ve sonuç, fixedDeltaTime ile çarpılarak uygulanır. Bu, topun hızını doğru bir şekilde hesaplamayı ve sabit bir hızla hareket etmesini sağlar.
fixedTime Özelliği
Unity Time sınıfı içinde yer alan fixedTime, oyun içerisindeki sabit bir zamanı ifade eder. Bu değer, oyun sahnesinin başlatılması anından itibaren geçen süreyi tutar ve her frame işlemi için bir kere artar. Bu özellik, FixedUpdate metodunda kullanılan zaman hesaplamaları için idealdir çünkü bu metot her frame işlemi için belirli bir zaman aralığında çağrılır.
Örneğin, bir araba yarışı oyununda, sabit bir araba hızı hesaplamak istediğimizi varsayalım. Arabanın hızını frame başına değişken olarak hesaplamak yerine sabit bir hızda hareket etmesini sağlamak isteyebiliriz. Bunu yapmak için FixedUpdate metodu içinde hareket kodumuzu yazabiliriz ve bu kodda Time.fixedDeltaTime değerini kullanarak hareket süresini hesaplayabiliriz. Örneğin, eğer arabanın sabit hızı 20 birim/sn ise ve FixedUpdate metodu 0.02 saniye aralıklarla çağrılıyorsa, arabanın her bir FixedUpdate çağrısı arasında 0.4 birim ilerlemesi gerekir. Bu durumda, kodumuz şu şekilde olabilir:
public class Araba : MonoBehaviour
{
public float hiz = 20f;
void FixedUpdate()
{
float hareketMesafesi = hiz * Time.fixedDeltaTime;
transform.position += Vector3.forward * hareketMesafesi;
}
} Burada, Araba sınıfının FixedUpdate metodu içinde hız değişkenine göre hareketMesafesi değeri hesaplanır ve transform.position ile arabayı hareket ettirilir. Time.fixedDeltaTime kullanarak sabit bir hızda hareket eden arabanın her frame işlemi arasındaki mesafeyi hesaplamış olduk.
fixedTimeAsDouble Özelliği
Unity Time sınıfının fixedTimeAsDouble Static Property’si, oyun dünyasının sabit zamanını tutmak için kullanılan bir değişkendir. Bu özellik, fixedDeltaTime gibi FixedUpdate() metodunda kullanılır ve her FixedUpdate() çağrısında güncellenir.
fixedTimeAsDouble, double türünde bir değişkendir ve saniye cinsinden oyunun başlangıcından bu yana geçen sabit zamanı tutar. Yani, oyun zamanı ne kadar yavaşlatılırsa yavaşlatsın, bu değer değişmez.
Örneğin, bir FPS oyununda düşmanların saldırı hızını ayarlamak için fixedTimeAsDouble kullanılabilir. Düşmanlar belirli bir aralıklarla saldırı yapmalıdır, ancak sabit delta zamanı kullandığımız için bu aralık zaman aralığı gerçek zamanla değişecektir. Bu nedenle, fixedTimeAsDouble değeri kullanılarak düşmanların saldırı aralıkları sabit kalabilir.
Aşağıdaki örnek, sabit zaman kullanarak topun hareketini simüle eder:
public class Ball : MonoBehaviour
{
public float speed = 10f;
private Rigidbody rb;
private void Start()
{
rb = GetComponent<Rigidbody>();
}
private void FixedUpdate()
{
// topun hareketini sabit zamanla güncelle
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(moveHorizontal, 0f, moveVertical);
rb.AddForce(movement * speed * Time.fixedDeltaTime);
}
} Bu örnekte, topun hareketi FixedUpdate() metodu kullanılarak güncellenir. Hareket vektörü, sabit zaman (fixedDeltaTime) ile çarpılarak her çağrıda güncellenir. Bu, oyunun herhangi bir hızda çalışabileceği anlamına gelir ve topun hareketi her zaman sabit kalır.
fixedUnscaledDeltaTime Özelliği
Unity Time sınıfı içinde yer alan fixedUnscaledDeltaTime özelliği, sabit bir zaman aralığını temsil eder ve bu zaman aralığı, ölçülen zamanın zaman ölçeğine bakılmaksızın (unscaled) her sabit adımda değişmez.
fixedUnscaledDeltaTime, Time.timeScale değerinin sıfır olması durumunda bile çalışır ve zaman ölçeği ile ilgili olmayan zaman aralıkları ölçümlemek için kullanılabilir.
Örneğin, oyun içinde bir menü açıldığında veya oyun duraklatıldığında zaman ölçeği (timescale) sıfır olabilir, ancak bu durumlarda da bazı işlemlerin belirli aralıklarla gerçekleştirilmesi gerekebilir. fixedUnscaledDeltaTime bu tür durumlarda kullanılabilir.
Aşağıdaki örnekte, oyun içindeki bir nesnenin her sabit adımda (fixedUpdate) hareket etmesi isteniyor, ancak oyun duraklatıldığında da hareket etmesi gerekiyor. Bu durumda fixedUnscaledDeltaTime özelliği kullanılabilir:
public class Example : MonoBehaviour
{
private Vector3 movementVector = new Vector3(1, 0, 0);
private float speed = 5f;
private void FixedUpdate()
{
transform.position += movementVector * speed * Time.fixedDeltaTime;
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
Time.timeScale = 0f; // Oyun duraklatılıyor
}
}
private void OnDisable()
{
Time.timeScale = 1f; // Oyun tekrar başlatılıyor
}
private void OnGUI()
{
if (Time.timeScale == 0f)
{
// Oyun duraklatıldığında hareket için fixedUnscaledDeltaTime kullanılıyor
transform.position += movementVector * speed * Time.fixedUnscaledDeltaTime;
GUI.Label(new Rect(10, 10, 100, 20), "Paused");
}
}
} Yukarıdaki örnekte, fixedUpdate() metodu içinde Time.fixedDeltaTime kullanarak nesnenin hareket etmesi sağlanıyor. Ancak OnGUI() metodu içinde, Time.timeScale değeri sıfır olduğunda da nesnenin hareket etmesi için fixedUnscaledDeltaTime kullanılıyor. Bu sayede oyun duraklatıldığında da nesne hareket etmeye devam eder. OnDisable() metodu ise oyun duraklatıldıktan sonra tekrar başlatıldığında Time.timeScale değerinin tekrar 1’e ayarlanmasını sağlar.
fixedUnscaledTime Özelliği
Unity Time sınıfı içerisinde yer alan fixedUnscaledTime özelliği, oyun objeleri ve fizik objeleri arasındaki zaman aralığını ölçmek için kullanılır. Bu özellik zaman zaman ölçerken, Time.timeScale özelliğinin etkisinden etkilenmez ve bu nedenle zaman ölçümleri her zaman aynı değeri döndürür.
Bu özellik, oyun motoru ile etkileşime geçen, fizik simülasyonu veya nesnelerin fiziksel davranışlarını kontrol eden scriptlerde kullanışlıdır. Özellikle zaman ölçümlerinin konsistan olması gereken durumlarda kullanılır.
Örnek olarak, bir araba yarışı oyunu düşünelim. Arabanın hızı, ivmesi ve diğer fiziksel özellikleri, Time.deltaTime gibi değerler kullanılarak hesaplanır. Ancak, yarış oyunları genellikle yarış arabasının diğer arabalardan bağımsız olarak hareket etmesini gerektirir. Bu durumda, zaman ölçümlerinin konsistan olması önemlidir ve fizik simülasyonunun zaman ölçümlerini fixedUnscaledTime özelliği ile yapmak daha uygun olabilir.
Aşağıdaki örnek, bir topun sabit bir hızla hareket etmesini sağlayan bir script’tir. Script’te, topun konumu ve hareket hızı fixedUnscaledTime özelliği kullanılarak güncellenir:
using UnityEngine;
public class BallMovement : MonoBehaviour
{
public float speed = 5.0f;
private void FixedUpdate()
{
Vector3 position = transform.position;
position.x += speed * Time.fixedUnscaledTime;
transform.position = position;
}
} Yukarıdaki script, topu sabit bir hızla hareket ettirir ve Time.timeScale etkisinde kalmadan zamanı ölçmek için fixedUnscaledTime özelliğini kullanır.
fixedUnscaledTimeAsDouble Özelliği
Unity Time sınıfının fixedUnscaledTimeAsDouble özelliği, oyunun işlemesi için ayrılan sabit zamana dayalı bir çift sayıdır. Bu özellik, Time.timeScale ayarlanarak zaman ölçeği faktörünün dikkate alınmadığı zaman tabanlı zamanı sağlar.
fixedUnscaledTimeAsDouble özelliği, Time.fixedUnscaledDeltaTime ile birlikte kullanılarak, zaman ölçeği faktörüne bağlı olmayan, sabit bir zaman adımı sağlamak için kullanılabilir. Örneğin, fizik simülasyonu gibi hassas zamanlama gerektiren durumlarda kullanılabilir.
Bir topun belirli aralıklarla hareket ettiği bir oyunu ele alalım. Topun hareketi, fizik simülasyonu kullanılarak hesaplanır ve sabit bir zaman adımı kullanılır. Bu zaman adımı, Time.timeScale ayarından bağımsızdır. Bu durumda, topun konumunu güncellemek için fixedUnscaledTimeAsDouble özelliği kullanılabilir. Örneğin, aşağıdaki kod örneği, topun sabit bir zaman aralığında hareket etmesini sağlayacak ve Time.timeScale ayarından bağımsız olarak çalışacaktır:
public float speed = 10f;
private float timeCounter = 0f;
void FixedUpdate() {
float fixedUnscaledDeltaTime = Time.fixedUnscaledDeltaTime;
timeCounter += fixedUnscaledDeltaTime;
float x = Mathf.Cos(timeCounter * speed) * 5f;
float y = Mathf.Sin(timeCounter * speed) * 5f;
transform.position = new Vector3(x, y, 0f);
} Bu kod örneği, fixedUnscaledTimeAsDouble özelliğinin kullanımını göstermektedir. Top, belirli bir hızda hareket eder ve transform.position özelliği, her sabit zaman adımında güncellenir. Time.timeScale ayarı değiştirilse bile, topun hareketi sabit kalacaktır.
frameCount Özelliği
Unity Time sınıfının frameCount Static Property’si, oyun sahnesinin başlangıcından itibaren oynatılan her kare sayısını tutar. Bu özellik özellikle oyun mekaniği veya zamanlama ile ilgili işlemlerde kullanılır.
Örneğin, bir nişancı oyunu yapmak istediğinizi varsayalım ve oyuncunun kaç kez ateş ettiğini takip etmek istediğinizi düşünün. Ateş etme işleminin gerçekleşmesi için belirli bir çerçeve sayısı gerekiyorsa, ateş etme işlemi gerçekleştiğinde frameCount özelliğini kontrol ederek ateş etme işleminin gerçekleşmesi için gereken çerçeve sayısını takip edebilirsiniz.
Örneğin, aşağıdaki kod örneği, her Update çağrısında frameCount özelliğini kontrol ederek, her 5. çerçevede “Ateş edildi!” mesajı yazdırır:
void Update()
{
if (Time.frameCount % 5 == 0) {
Debug.Log("Ateş edildi!");
}
} Bu kod örneğinde, frameCount özelliği mod işlemi ile kontrol edilir ve 5’e bölümünden kalanın sıfıra eşit olması durumunda “Ateş edildi!” mesajı yazdırılır. Bu örnek, frameCount özelliğinin bir oyunun mekaniği için nasıl kullanılabileceğini göstermektedir.
inFixedTimeStep Özelliği
Unity Time sınıfının inFixedTimeStep static özelliği, oyun motorunun güncelleme periyodu için sabit bir zaman adımı kullanılıp kullanılmadığını belirten bir boolean değişkendir. Bu özellik, sabit bir zaman adımı kullanılıyorsa “true” ve aksi takdirde “false” değerini alır.
Sabit zaman adımı, oyun motorunun güncelleme zamanını sabit bir değere ayarlayarak, oyunun farklı platformlarda ve farklı işlem hızlarında bile aynı hızda çalışmasını sağlar. Bu, oyun içindeki fizik tabanlı etkileşimlerin tutarlı bir şekilde işlenmesine ve oyun deneyiminin iyileştirilmesine yardımcı olabilir.
Aşağıdaki örnek, inFixedTimeStep özelliğinin kullanımını göstermektedir:
void Update()
{
if (Time.inFixedTimeStep)
{
Debug.Log("Fixed time step is enabled.");
}
else
{
Debug.Log("Fixed time step is not enabled.");
}
} Bu örnek, oyun motoru sabit bir zaman adımı kullanıyorsa “Fixed time step is enabled.” mesajını ve aksi takdirde “Fixed time step is not enabled.” mesajını gösterir. Bu, oyun geliştiricilerinin oyunun performansını izlemelerine ve gerekirse güncelleme periyodunu ayarlamalarına yardımcı olabilir.
maximumDeltaTime Özelliği
Unity Time sınıfının maximumDeltaTime static özelliği, her bir frame’in süresini sınırlamak için kullanılan bir değeri temsil eder. Varsayılan olarak, Unity her bir frame için maksimum 0.33 saniye tanımlar. Bu, bir frame’in işlemesi daha uzun sürerse, bir sonraki frame’in atlanacağı anlamına gelir.
Bu özellik özellikle oyuncuların oyunun yavaşlamasını veya donmasını önlemek için kullanılır. Örneğin, bir oyuncu birkaç saniye boyunca oyundan çıkarsa ve ardından tekrar oyunu açarsa, birikmiş işlem yükü oyunun hızını düşürebilir. maximumDeltaTime değeri bu durumda kullanılabilir ve aşırı işlem yükü nedeniyle yaşanabilecek yavaşlamayı önleyebilir.
Aşağıdaki örnekte, maximumDeltaTime kullanılarak her bir frame’in maksimum süresi 0.1 saniye olarak sınırlandırılıyor:
void Update()
{
if (Time.maximumDeltaTime > 0.1f)
{
Time.maximumDeltaTime = 0.1f;
}
// diğer kodlar
} Bu örnekte, her bir frame’in süresi 0.1 saniyeyi geçerse, maximumDeltaTime değeri 0.1 saniye olarak ayarlanır. Böylece, bir sonraki frame, aşırı işlem yükü nedeniyle yavaşlama yaşanmadan işlenir.
maximumParticleDeltaTime Özelliği
Unity Time sınıfının maximumParticleDeltaTime özelliği, bölük zaman adımındaki en fazla değişim aralığını belirler. Bu, özellikle büyük hareketler içeren partikül sistemleri gibi fizik tabanlı animasyonların hesaplanmasında önemlidir.
Bu özellik, Time sınıfının diğer özellikleri gibi önceden tanımlanmış bir sabittir ve sahne görüntülenirken Unity tarafından kullanılır. Varsayılan değeri, 0.03 saniyedir ve bu, her bir zaman adımındaki en fazla değişim süresini sınırlar. Bu, özellikle büyük hareketler içeren partikül sistemleri gibi fizik tabanlı animasyonların hesaplanmasında önemlidir.
Örneğin, bir oyunda patlayan bir bomba animasyonu oluşturmak istediğimizi düşünelim. Patlamayı bir partikül sisteminden oluşturacağız ve bu partikül sistemi, bombanın patlama hareketini taklit etmek için fizik tabanlı animasyon kullanıyor olabilir. Bu durumda, partikül sisteminin hesaplanması için büyük bir değişim süresi kullanmamız gerekebilir. Ancak, bunun bir sınırı olmalıdır, çünkü yüksek bir değişim süresi kullanmak, performans sorunlarına neden olabilir ve animasyonun doğru görünmemesine sebep olabilir. Bu durumda, maximumParticleDeltaTime özelliğini kullanarak partikül sistemi için en yüksek değişim aralığını belirleyebiliriz. Örneğin, bombanın patlaması için bir değişim süresi olarak 0.05 saniye kullanmak isteyebiliriz. Bunu yapmak için, maximumParticleDeltaTime özelliğine 0.05 değerini atayabiliriz.
Time.maximumParticleDeltaTime = 0.05f;
Bu, partikül sistemi için zaman adımlarının maksimum 0.05 saniye sürebileceğini belirler. Bu, animasyonun doğru bir şekilde hesaplanmasını sağlar ve performans sorunlarını önler.
realtimeSinceStartup Özelliği
Unity’deki Time sınıfının realtimeSinceStartup static özelliği, oyunun başlatıldığı andan itibaren geçen gerçek zamanın toplam süresini saniye cinsinden tutar. Bu özellik, zamanlayıcılar oluşturmak veya performans ölçümleri yapmak gibi senaryolarda kullanılabilir.
Örneğin, bir oyunun başlatılmasından bu yana geçen süreyi ekrana yazdırmak istediğimizi düşünelim. Bu durumda, aşağıdaki kod bloğunu kullanabiliriz:
void Update()
{
float elapsedTime = Time.realtimeSinceStartup;
Debug.Log("Geçen süre: " + elapsedTime + " saniye");
} Bu kod, her güncelleme döngüsünde geçen süreyi hesaplar ve Debug.Log() fonksiyonu aracılığıyla ekrana yazdırır.
realtimeSinceStartup özelliği aynı zamanda oyun içinde zamanlayıcılar oluşturmak için de kullanılabilir. Örneğin, belirli bir animasyonun oynatılması için bir bekleme süresi ayarlamak istediğimizi varsayalım. Bu durumda, aşağıdaki kod bloğunu kullanabiliriz:
IEnumerator PlayAnimationAfterDelay(float delay)
{
yield return new WaitForSeconds(delay);
animation.Play();
} Bu kod, PlayAnimationAfterDelay() adlı bir IEnumerator işlevi tanımlar. Bu işlev, belirtilen gecikme süresi kadar bekledikten sonra bir animasyonu oynatır. WaitForSeconds() fonksiyonu, gerçek zaman geçişlerine göre çalışır, bu nedenle zaman ölçeği veya zamanlama hatalarından etkilenmez.
smoothDeltaTime Özelliği
Unity’deki Time sınıfının smoothDeltaTime adlı özelliği, son birkaç kare arasındaki deltaTime değerlerinin ortalamasıdır. Bu özellik, oyun içi nesnelerin hareketini daha yumuşak hale getirmek için kullanılır.
Örneğin, bir araba oyununda arabanın hareketini kontrol eden bir script yazalım. Arabanın hızı, kullanıcının girdiği değerlere bağlı olarak değişecektir. Ancak, arabanın hızını deltaTime ile çarptığımızda, araba ani bir şekilde hareket edebilir. Bu nedenle, smoothDeltaTime kullanarak arabanın hızını zamanla yumuşatmak isteyebiliriz.
Örnek kodda, arabanın hızı deltaTime yerine smoothDeltaTime ile çarpılarak kullanılıyor:
public float carSpeed = 10f;
private float currentSpeed = 0f;
void Update()
{
float input = Input.GetAxis("Vertical");
currentSpeed += input * carSpeed * Time.smoothDeltaTime;
transform.Translate(Vector3.forward * currentSpeed);
} Bu kodda, arabanın hızı smoothDeltaTime ile çarpılarak değiştiriliyor. Bu, arabanın daha yumuşak bir şekilde hareket etmesini sağlar.
time Özelliği
Unity Time sınıfı, oyunlarda zamanlama işlemlerini yönetmek için kullanılan bir sınıftır. Bu sınıf, zamanla ilgili özellikler ve yöntemler sağlayarak oyun sahnesindeki nesnelerin zamanlama davranışlarını kontrol etmeyi sağlar.
Unity Time sınıfında yer alan time özelliği, oyun sahnesindeki zamanı temsil eder. Bu özellik, oyunun başlangıcından beri geçen zamanı saniye cinsinden tutar. Bu özellik, özellikle oyunlarda belirli zaman aralıklarında çalışacak işlevler veya nesnelerin belirli zamanlarda etkinleştirilmesi gereken senaryolarda kullanılır.
Örneğin, bir oyun sahnesinde bir düşmanın belirli aralıklarla ateş etmesi gerekiyorsa, bu ateş fonksiyonunun çalışması için belirli bir zamanlama gerekebilir. Bu durumda, zamanlama işlemleri için Unity Time sınıfındaki time özelliği kullanılabilir. Aşağıdaki örnek, belirli aralıklarla ateş eden bir düşmanın örneğidir:
using UnityEngine;
public class Enemy : MonoBehaviour
{
public float fireRate = 2f;
private float nextFireTime = 0f;
public void Update()
{
if (Time.time > nextFireTime)
{
Fire();
nextFireTime = Time.time + fireRate;
}
}
public void Fire()
{
// ateş etme işlemleri burada yapılır
}
} Bu örnekte, Update() fonksiyonu her karede çağrılır ve belirli bir süre geçtikten sonra düşman ateş eder. nextFireTime değişkeni, bir sonraki ateş zamanını hesaplamak için kullanılır. Eğer oyun sahnesinde geçen toplam zaman, nextFireTime değişkeninin değerinden büyükse, Fire() fonksiyonu çağrılır ve nextFireTime değişkeni güncellenir.
Böylece, Unity Time sınıfının time özelliği sayesinde, belirli aralıklarla ateş eden bir düşmanın zamanlama işlemleri kolaylıkla yönetilebilir.
timeScale Özelliği
Unity Time sınıfının timeScale Static Properties’i, oyunun zaman ölçeğini belirler. Bu özellik, oyun zamanını hızlandırmak veya yavaşlatmak için kullanılabilir. Varsayılan değeri 1’dir, yani oyun normal hızda ilerler.
timeScale özelliği, zamanla ilgili işlemler yaparken çok faydalıdır. Örneğin, bir oyun karakterinin hareketi, zamanın ilerlemesine bağlıdır. Eğer timeScale değeri 1 ise, oyun karakteri normal hızda hareket eder. Ancak, timeScale değeri 2 yapıldığında, oyun karakteri iki kat daha hızlı hareket eder. Benzer şekilde, timeScale değeri 0.5 olarak ayarlandığında, oyun karakteri yavaşlar ve yarı hızda hareket eder.
Aşağıdaki örnekte, bir butona tıklama ile oyun zamanı hızlandırılmaktadır:
using UnityEngine;
public class TimeController : MonoBehaviour
{
private float initialTimeScale;
void Start()
{
initialTimeScale = Time.timeScale;
}
public void SpeedUpTime()
{
Time.timeScale = 2f;
}
public void ResetTimeScale()
{
Time.timeScale = initialTimeScale;
}
} Bu örnek, Time.timeScale özelliğini 2 olarak ayarlar ve oyun hızlandırılır. ResetTimeScale() metodu, zaman ölçeğini başlangıçta kaydedilen değere geri yükler ve normal hızda oyun oynamaya devam eder. Bu örnek, bir butona tıklama olayı tarafından tetiklenebilir ve oyunun zaman hızını artırmak veya sıfırlamak için kullanılabilir.
timeSinceLevelLoad Özelliği
Unity Time sınıfının timeSinceLevelLoad Static Properties özelliği, sahne yüklenmesinden beri geçen zamanı saniye cinsinden tutar. Bu özellik, sahnenin yüklenmesiyle birlikte sıfırlanır ve sahne değiştirilse bile sıfırlanmaz.
Örneğin, bir oyunun menü sahnesinden ana oyun sahnesine geçiş yaptığınızı düşünelim. Bu geçişte, timeSinceLevelLoad özelliği sıfırlanmaz ve ana oyun sahnesindeki tüm zamanlama işlemleri menü sahnesinde geçen süreyi de hesaba katarak doğru bir şekilde yapılır.
using UnityEngine;
public class Zamanlama : MonoBehaviour
{
private float sahneYuklenmeZamani;
void Start()
{
sahneYuklenmeZamani = Time.timeSinceLevelLoad;
}
void Update()
{
float gecenSure = Time.timeSinceLevelLoad - sahneYuklenmeZamani;
if (gecenSure >= 10f) // 10 saniye geçtiğinde bir şey yap
{
// 10 saniye geçtiğinde yapılacak işlemler burada
}
}
} Bu örnekte, Start() metodu sahne yüklendiğinde sahne yüklenme zamanını Time.timeSinceLevelLoad özelliği ile alır. Update() metodu içinde, geçen süre hesaplanır ve belirli bir süre geçtikten sonra yapılacak işlemler yapılır. Bu sayede, oyun sahnesindeki geçen süreye göre zamanlama işlemleri doğru bir şekilde gerçekleştirilir.
timeSinceLevelLoadAsDouble Özelliği
Unity Time sınıfının timeSinceLevelLoadAsDouble Static Properties özelliği, sahne yüklenmesinden bu yana geçen süreyi ikili (double) olarak döndürür. Bu özellik, zamanla ilgili işlemlerde kullanılabilir.
Örneğin, bir oyunun başında bir sahne yükledikten sonra geçen süreyi ölçmek istediğimizi varsayalım. Bu durumda, timeSinceLevelLoadAsDouble özelliği kullanılabilir. Aşağıdaki örnek, oyunun başında sahnenin yüklenmesinden bu yana geçen süreyi hesaplar ve konsola yazdırır:
void Start()
{
double timeSinceLoad = Time.timeSinceLevelLoadAsDouble;
Debug.Log("Sahne yüklendikten bu yana geçen süre: " + timeSinceLoad);
} Bu örnekte, Start() fonksiyonu, sahne yüklendiğinde çalıştırılır ve timeSinceLevelLoadAsDouble özelliği kullanılarak geçen süre hesaplanır. Bu değer daha sonra konsola yazdırılır. Bu özellik, sahne yüklendiğinde ve oyun başladığında zaman ölçümleri için kullanışlıdır.
timeAsDouble Özelliği
Unity Time sınıfı içindeki timeAsDouble Static Properties, sahne zamanını çift hassasiyetli bir kayan nokta olarak verir. Bu, zaman ölçeğine (timeScale) ve zaman içinde ilerleme (elapsedTime) etkisine sahip değildir.
Örneğin, bir oyun sahnesinde zamanın belirli bir zaman diliminde sabit kalması gerektiğini varsayalım. Bu durumda, timeAsDouble özelliği kullanılarak zamanı sabit tutabiliriz. Örneğin, sahnenin başlangıcında aşağıdaki kodu yazarak, zamanı sabit tutabiliriz:
public class GameManager : MonoBehaviour
{
private double startTime;
void Start()
{
// Başlangıç zamanını kaydedin
startTime = Time.timeAsDouble;
}
void Update()
{
// Geçen süreyi hesaplayın
double elapsedTime = Time.timeAsDouble - startTime;
// Zamanı sabit tutmak için işlemler yapın
// ...
}
} Bu kodda, Start() metodunda zamanı başlangıç zamanı olarak kaydediyoruz. Update() metodunda ise, geçen süreyi hesaplayarak zamanı sabit tutmak için gereken işlemleri yapabiliriz.
Örneğin, zamanı sabit tutarak bir animasyon oluşturmak için, animasyonun her bir karesinin belirli bir zaman diliminde gösterilmesi gerektiğini düşünebiliriz. Bu durumda, her kare gösterildiğinde elapsedTime değeri kullanılarak kareler arası geçiş süresi hesaplanabilir.
unscaledDeltaTime Özelliği
Unity’nin zaman ölçümü ile ilgili birçok özelliği vardır ve unscaledDeltaTime bunlardan biridir. unscaledDeltaTime, zaman ölçeğine (timeScale) bağlı olmayan bir zaman farkıdır. Yani, zaman ölçeği 0.5 ise, deltaTime, unscaledDeltaTime’nun iki katı olacak ve yarım saniyede bir kez güncellenecektir.
Örneğin, bir oyun geliştiricisi oyunu duraklatmak istediğinde, zaman ölçeğini 0’a ayarlayarak oyunu duraklatabilir, ancak hala hareket eden nesnelerin konumlarını güncellemek için unscaledDeltaTime’yu kullanabilir. Bu, hareket eden nesnelerin görünümünün donduğu, ancak diğer işlemlerin devam ettiği bir durum yaratır.
Aşağıdaki örnekte, unscaledDeltaTime kullanarak bir nesneyi belirli bir hızda ileri doğru hareket ettiriyoruz, ancak zaman ölçeğini değiştirerek hareket hızını yavaşlatabiliyoruz:
public float speed = 10f;
void Update()
{
transform.position += Vector3.forward * speed * Time.unscaledDeltaTime;
if (Input.GetKeyDown(KeyCode.Space))
{
Time.timeScale = 0.5f;
}
if (Input.GetKeyUp(KeyCode.Space))
{
Time.timeScale = 1f;
}
} Bu örnekte, “speed” değişkeni, nesnenin ileri doğru hareket edeceği hızı belirler. Update() fonksiyonunda, transform.position += Vector3.forward * speed * Time.unscaledDeltaTime; kod satırı, nesnenin unscaledDeltaTime ile belirlenen hızda ileri doğru hareket etmesini sağlar. Ayrıca, kullanıcının “Space” tuşuna basarak zaman ölçeğini değiştirebiliriz, bu da nesnenin hareket hızını etkiler.
unscaledTime Özelliği
olmadan geçen süreyi saniye cinsinden temsil eder. Bu özellik, zaman ölçeği değeri değiştirildiğinde bile sabit bir zaman birimi sağlar.
Örneğin, eğer zaman ölçeği değeri 0.5 olarak ayarlanmışsa, zaman normal hızının yarısı kadar hızda geçer. Ancak unscaledTime özelliği, bu durumda bile zamanın normal hızında ilerleyen süresini tutar.
Aşağıdaki örnek, topun belirli bir mesafeyi bir saniyede katetmesi için gereken süreyi hesaplamak için unscaledTime özelliğini kullanır:
public class BallMovement : MonoBehaviour
{
public float speed = 10.0f; // topun hızı
private float startTime; // hareketin başlangıç zamanı
private float distanceToTravel = 10.0f; // topun kat etmesi gereken mesafe
void Start()
{
startTime = Time.unscaledTime; // hareket başlangıç zamanını kaydet
}
void Update()
{
float distanceCovered = (Time.unscaledTime - startTime) * speed; // kat edilen mesafe = zaman * hız
float fractionOfJourney = distanceCovered / distanceToTravel; // kat edilen mesafenin toplam mesafeye oranı
transform.position = Vector3.Lerp(transform.position, transform.position + Vector3.right * distanceToTravel, fractionOfJourney); // topu ileri hareket ettir
}
} Bu örnekte, Start() yöntemi, hareketin başlangıç zamanını Time.unscaledTime ile kaydeder. Update() yöntemi, topun sürekli olarak ileri hareket etmesini sağlar ve kat edilen mesafeyi hesaplamak için unscaledTime özelliğini kullanır. transform.position özelliği, topun konumunu günceller. Lerp yöntemi, topun hareket etmesini sağlar ve fractionOfJourney değişkeni, topun hareket etmesinin yüzdesini hesaplar.
unscaledTimeAsDouble Özelliği
Unity’deki Time sınıfının unscaledTimeAsDouble Static Property’si, oyunun başladığı andan bu yana geçen zamanı (saniye cinsinden) hesaplayan bir özelliktir. UnscaledTimeAsDouble, oyun zaman ölçeğinin (timeScale) etkisinden bağımsız olarak çalışır, yani zaman ölçeği değiştirildiğinde değişmez.
Örneğin, bir oyun içinde bir nesnenin konumunu değiştirmek için kullanabilirsiniz. Eğer oyun zaman ölçeği (timeScale) 2 olarak ayarlanırsa, normal zaman akışı iki katına çıkar, ancak unscaledTimeAsDouble, zaman ölçeğinden bağımsız olarak normal zaman akışı boyunca devam eder.
Aşağıda, unscaledTimeAsDouble özelliğinin nasıl kullanılabileceğine dair basit bir örnek gösterilmiştir:
public class ObjectMovement : MonoBehaviour
{
public float speed = 5f;
// Update is called once per frame
void Update()
{
transform.position = new Vector3(Mathf.PingPong(Time.unscaledTimeAsDouble * speed, 10), transform.position.y, transform.position.z);
}
} Bu örnek, unscaledTimeAsDouble özelliğini kullanarak, bir nesnenin yatay konumunu (x koordinatı) matematiksel olarak hesaplamaktadır. PingPong fonksiyonu, bir zaman damgası ve bir aralık (range) değeri alır ve zaman damgasının aralıkta ileri geri hareket etmesini sağlar. Bu örnekte, nesnenin konumunun x koordinatı, unscaledTimeAsDouble değerinin (hız sabitiyle çarpılmış) 0 ila 10 arasındaki aralıkta ileri geri hareket etmesiyle belirlenir.
Böylece, unscaledTimeAsDouble özelliği sayesinde nesnenin konumu, zaman ölçeği değiştirildiğinde bile doğru bir şekilde hesaplanır ve nesne her zaman aynı hızda hareket eder.
Kaynaklar: