Unity oyun motorunda yer alan Debug sınıfı, geliştiricilerin uygulama yazılırken hata ayıklamasına yardımcı olmak için kullanabileceği bir araçtır. Debug sınıfı, uygulamanın çalışma zamanında çeşitli hata ayıklama yöntemleri sağlar ve hataları tespit etmek ve gidermek için kullanışlı fonksiyonlar sunar.
Debug sınıfı, uygulamanın çalışma zamanında hata ayıklama yapmak için kullanılan birkaç farklı yöntem sunar. Bunlar arasında Log, LogWarning, LogError ve LogException fonksiyonları yer alır. Bu fonksiyonlar, uygulamanın çalışma zamanında belirli bilgileri yazdırmak veya bir hata meydana geldiğinde uygun şekilde işlem yapmak için kullanılabilir.
Ayrıca Debug sınıfı, DrawLine, DrawRay, DrawCube, DrawSphere gibi çizim fonksiyonları da sunar. Bu fonksiyonlar, geliştiricilerin uygulamalarının çalışma zamanında görsel olarak kontrol etmelerine ve sorunları tespit etmelerine yardımcı olabilir.
Debug sınıfı, uygulamanın performansını da ölçmek için kullanışlı fonksiyonlar içerir. Örneğin, Debug.Log zaman damgasıyla birlikte çağrıldığında, uygulamanın çalışma süresinin izlenebileceği bir zaman damgası ekranında görüntülenebilir.
Genel olarak, Debug sınıfı, uygulama yazılırken geliştiricilerin hata ayıklama yapmalarına, uygulamanın performansını ölçmelerine ve hataları gidermelerine yardımcı olmak için kullanışlı bir araçtır.
Debug Sınıfı Metodları (Static Methods)
Assert Metodu
Unity’nin Debug sınıfı, hata ayıklama ve kodu analiz etmek için kullanılan bir dizi yöntem içerir. Bu yöntemlerden biri de Assert() yöntemidir.
Assert() yöntemi, belirtilen koşulun doğru olup olmadığını kontrol eder. Eğer koşul doğru değilse, programın çalışması durdurulur ve bir hata mesajı görüntülenir. Assert() yöntemi, yazılım testleri yaparken, özellikle hata ayıklama amaçları için kullanışlıdır.
Assert() yöntemi iki parametre alır: bir koşul ifadesi ve bir hata mesajı. Koşul ifadesi, doğru veya yanlış olarak değerlendirilebilen bir ifadedir. Eğer koşul yanlışsa, hata mesajı görüntülenir ve program durdurulur.
Aşağıda bir örnek kullanımı gösterilmiştir:
void Start()
{
int playerHealth = 100;
int damageTaken = 110;
// Eğer oyuncunun sağlığı sıfırdan küçükse (yani eksi bir değer ise), bir hata mesajı görüntüle
Assert.IsTrue(playerHealth >= 0, "Oyuncu sağlığı negatif bir değer alamaz.");
// Eğer oyuncunun aldığı hasar değeri sıfırdan büyükse (yani oyuncu ölmüş ise), bir hata mesajı görüntüle
Assert.IsFalse(damageTaken > 0, "Oyuncu ölmüş olmalı.");
// Bu noktaya geldiğimizde, oyuncunun sağlığı sıfırdan büyük ve aldığı hasar sıfırdan küçük veya eşit olduğu varsayılır.
Debug.Log("Oyuncu hayatta kaldı.");
}
Bu örnekte, oyuncunun skoru, gereken skordan daha düşük olduğunda Debug.Assert() yöntemi çağrılır ve bir hata mesajı görüntülenir. Bu, geliştiricinin kodu hızla test edebilmesini ve hataları bulup düzeltmesini kolaylaştırır.
AssertFormat Metodu
Unity oyun motorunda, Debug sınıfı AssertFormat metodu, Assert metoduna benzer şekilde çalışır, ancak bu metot aynı zamanda bir string formatlama işlemi gerçekleştirir.
Bu metot, Assert metodu gibi bir koşulu kontrol eder ve eğer koşul sağlanmazsa, bir hata mesajı görüntülenir. Ancak, AssertFormat metodu, hata mesajını string formatlama yoluyla oluşturur. Yani, bir hata mesajında değişkenlerin ve diğer verilerin kullanılması gerektiğinde bu metot kullanılabilir.
Metodun imzası şu şekildedir:
public static void AssertFormat(bool condition, string format, params object[] args);
- condition: Koşul, true ise hiçbir şey yapılmaz, false ise hata mesajı görüntülenir.
- format: Hata mesajını oluşturmak için kullanılan string formatı.
- args: String formatındaki değişkenlerin değerleri.
Örnek olarak, bir oyuncunun sahip olması gereken en az para miktarını kontrol ettiğimizi varsayalım. Eğer oyuncunun sahip olduğu para miktarı minimum gereksinimi karşılamıyorsa, bir hata mesajı görüntüleyeceğiz. Bu durumda, AssertFormat metodu kullanılabilir:
int minimumPara = 100;
int oyuncununParasi = 50;
Debug.AssertFormat(oyuncununParasi >= minimumPara, "Oyuncunun en az {0} parası olması gerekir, ancak şu anda {1} parası var", minimumPara, oyuncununParasi);
Bu örnekte, oyuncunun minimum gereksinimi karşılamadığı durumlarda, bir hata mesajı görüntülenir. Hata mesajı, minimum gereksinimi ve oyuncunun sahip olduğu para miktarını gösterir. Bu sayede, hata ayıklama süreci daha da kolaylaşır.
Break Metodu
Unity oyun motorunda Debug sınıfında yer alan Break metodu, uygulama çalışırken belirli bir koşulun sağlandığı durumlarda, uygulamanın çalışmasını durdurur ve editörde uygulama durduğu noktada bir hata iletisi görüntülemeyi sağlar. Bu özellik sayesinde, belirli bir koşulun karşılanıp karşılanmadığını ve bu koşulun neden olduğu hata kaynağını tespit etmek için kullanılabilir.
Break metodunun kullanımı oldukça basittir. Belirli bir koşulun sağlandığı bir yerde, Debug.Break() kod satırını eklemek yeterlidir. Bu kod satırı, uygulama çalıştığında ilgili koşulun sağlandığı yere gelindiğinde, uygulama çalışmasını durdurur ve editörde hata ayıklama moduna geçilir. Bu sayede, uygulamanın çalışmasını adım adım izleyebilir ve hata kaynağını tespit edebilirsiniz.
Aşağıda, Break metodunun bir örneği verilmiştir:
int playerHealth = 0;
if (playerHealth <= 0)
{
Debug.Break();
// burada uygulama durur ve hata ayıklama moduna geçilir
}
Bu örnekte, playerHealth değişkeninin 0’dan küçük veya eşit olması durumunda, Debug.Break() metodu çağrılır ve uygulama çalışması durdurulur. Bu sayede, playerHealth değişkeninin neden 0’dan küçük veya eşit olduğu tespit edilebilir.
ClearDeveloperConsole Metodu
Unity oyun motorunda Debug sınıfı içerisinde yer alan ClearDeveloperConsole metodu, konsol penceresindeki tüm çıktıları temizlemek için kullanılır. Bu metod sayesinde, konsol penceresindeki tüm önceki hatalar, uyarılar ve diğer mesajlar silinerek temiz bir konsol penceresi elde edilebilir.
Metodun kullanımı oldukça basittir. Sadece Debug sınıfının ClearDeveloperConsole metodunu çağırmak yeterlidir. Örneğin:
Debug.ClearDeveloperConsole();
Bu örnekte, ClearDeveloperConsole metodunu çağırarak konsol penceresindeki tüm çıktıları temizleyebiliriz.
Bu metodun kullanımı, özellikle uzun bir çalışma süresinden sonra konsol penceresinde birikmiş çıktıları temizlemek için oldukça faydalıdır. Ayrıca, geliştirme sırasında sık sık hata ayıklama yaparken de kullanışlıdır, böylece konsol penceresindeki tüm hatalar ve uyarılar silinerek daha net bir görünüm elde edilir.
DrawLine Metodu
Unity oyun motorunda Debug sınıfı, geliştiricilere hata ayıklama işlemleri için bir dizi faydalı araçlar sağlar. Bu araçlar arasında DrawLine metodu da bulunur. Bu metot, 3 boyutlu uzayda iki nokta arasında bir çizgi çizer.
DrawLine metodunun imzası şu şekildedir:
public static void DrawLine(Vector3 start, Vector3 end, Color color = default(Color), float duration = 0, bool depthTest = true);
- start: çizginin başlangıç noktasını belirleyen Vector3.
- end: çizginin bitiş noktasını belirleyen Vector3.
- color (isteğe bağlı): çizgi rengini belirleyen Color yapısı.
- duration (isteğe bağlı): çizginin ne kadar süre boyunca görüntüleneceğini belirleyen float değeri. Varsayılan değer sıfırdır, yani çizgi sadece bir frame boyunca görüntülenecektir.
- depthTest (isteğe bağlı): Çizginin diğer nesnelerin arkasına geçip geçmeyeceğini belirleyen boolean değeri. Varsayılan değer true’dır, yani çizgi diğer nesnelerin arkasına geçmez.
Aşağıdaki örnek, iki nokta arasında bir çizgi çizer:
using UnityEngine;
public class DrawLineExample : MonoBehaviour
{
public Transform start;
public Transform end;
private void OnDrawGizmos()
{
Debug.DrawLine(start.position, end.position, Color.green);
}
}
Bu örnekte, DrawLine metodu OnDrawGizmos yönteminde kullanılmıştır. Bu, sahne görünümünde Gizmo olarak görüntülenen bir nesne ile çalıştığımızda kullanılan bir yöntemdir. DrawLine metodunun başlangıç ve bitiş noktaları, Transform nesneleri kullanılarak ayarlanmıştır. Bu nedenle, çizgi her seferinde bu nesnelerin pozisyonlarına göre yeniden çizilecektir.
DrawRay Metodu
Unity oyun motorunda Debug sınıfında yer alan DrawRay metodu, 3 boyutlu uzayda bir başlangıç noktası ve bir yön vektörü vererek, belirli bir mesafeye kadar çizgi şeklinde bir ışın çizmenizi sağlar.
Metodun imzası şu şekildedir:
public static void DrawRay(Vector3 start, Vector3 dir, Color color = Color.white, float duration = 0, bool depthTest = true)
Parametreleri şu şekildedir:
- start: Çizgi başlangıç noktası. Vector3 tipinde olmalıdır.
- dir: Çizgi yönü. Vector3 tipinde olmalıdır.
- color: Çizginin rengi. Varsayılan değeri beyazdır.
- duration: Çizginin ne kadar süre boyunca gösterileceği. Varsayılan değeri 0’dır, yani sadece bir frame boyunca gösterilir.
- depthTest: Eğer true olarak ayarlanırsa, çizgi örtüşmeleri hesaplamak için z-buffer kullanır. Varsayılan değeri
true‘dır.
Örnek olarak, aşağıdaki kod bloğu, kameranın pozisyonunda bir ışın çizer:
using UnityEngine;
public class RayDrawer : MonoBehaviour
{
public float rayLength = 10f;
void Update()
{
// Kameranın konumunu alıyoruz
Vector3 startPos = transform.position;
// Kameranın önünde olan bir noktayı buluyoruz
Vector3 endPos = transform.position + transform.forward * rayLength;
// DrawRay metodunu kullanarak ışını çiziyoruz
Debug.DrawRay(startPos, transform.forward * rayLength, Color.red);
}
}
Bu kod, kamera pozisyonundan ileriye doğru bir kırmızı ışın çizer.
ExtractStackTraceNoAlloc Metodu
Unity oyun motorunda Debug sınıfında yer alan ExtractStackTraceNoAlloc metodu, hata ayıklama ve hata raporlama için kullanılan bir metodtur. Bu metot, çağrı yığınında (stack trace) bulunan tüm işlev adlarını ve dosya yollarını, bir string dizisi şeklinde döndürür.
Metod, string dizisi oluşturmak için heap üzerinde yer ayırmadan çalışır, bu nedenle performans açısından daha iyidir. Ancak, string dizisi boyutu önceden belirlenmediği için, döndürülen dizi, çağrı yığınının uzunluğuna bağlı olarak değişebilir.
Aşağıda, ExtractStackTraceNoAlloc metodu için bir örnek verilmiştir:
void SampleMethod()
{
try
{
// Hata fırlatılacak kod bloğu
}
catch (Exception e)
{
string[] stackTrace = Debug.ExtractStackTraceNoAlloc(e);
Debug.LogFormat("Hata: {0}\nÇağrı yığını:\n{1}", e.Message, string.Join("\n", stackTrace));
}
}
Bu örnekte, bir hata oluştuğunda, hata ve çağrı yığını bilgileri Debug.LogFormat() metodu kullanılarak konsola yazdırılır. ExtractStackTraceNoAlloc metodu, try-catch bloğunda fırlatılan hatanın çağrı yığını bilgilerini almak için kullanılır. Daha sonra, string.Join() metodu kullanılarak çağrı yığını dizisi tek bir string’e dönüştürülür ve konsola yazdırılır.
Log Metodu
Unity oyun motorunda Debug sınıfında yer alan Log metodu, konsola belirtilen mesajı ve isteğe bağlı olarak belirtilen objenin string temsilini yazar. Bu metot, programcıların çalışan kodun belirli noktalarında mesajlar göndererek kod hakkında bilgi edinmelerine yardımcı olur.
Log metodu aşağıdaki gibi kullanılır:
Debug.Log("Merhaba Dünya!");
Bu örnek, “Merhaba Dünya!” mesajını konsola yazar. İsteğe bağlı olarak, bir nesnenin string temsilini de ekleyebilirsiniz:
GameObject player = GameObject.Find("Player");
Debug.Log("Oyuncu konumu: " + player.transform.position);
Bu örnek, “Oyuncu konumu: (x, y, z)” şeklinde bir mesajı konsola yazar.
Log metodu ayrıca, mesajın önem derecesini belirten bir ikinci parametre de alabilir. Bu parametre, LogType enum’ından bir değer olmalıdır. Örneğin:
int health = 10;
if (health <= 0) {
Debug.Log("Öldünüz!", LogType.Warning);
} else {
Debug.Log("Sağlık: " + health);
}
Bu örnekte, sağlık değeri sıfır veya altında ise “Öldünüz!” mesajı sarı renkte bir uyarı olarak konsola yazılır. Sağlık değeri pozitif ise, sağlık değeri yeşil renkte bir bilgi olarak konsola yazılır.
Log metodu, programcıların kodlarında hata ayıklama yaparken çok işe yarayan bir metottur. Doğru kullanıldığında, hataları bulmak ve ayıklamak için önemli bir araç olabilir.
LogAssertion Metodu
Unity oyun motorunda Debug sınıfının LogAssertion metodu, Debug.Log ve Debug.Assert metodlarının bir karışımıdır. Bu metod, belirtilen koşulun doğru olmadığı durumda bir hata mesajı gösterir ve Debug.Log metodu gibi loglama işlevi de görür.
LogAssertion metodu aşağıdaki şekilde kullanılabilir:
bool isTrue = false; Debug.LogAssertion(isTrue, "isTrue değişkeni yanlış değer içeriyor!");
Yukarıdaki örnekte, “isTrue değişkeni yanlış değer içeriyor!” hatası yalnızca isTrue değişkeni false olduğunda görüntülenecektir. Eğer isTrue değişkeni true değerini içeriyorsa, hiçbir şey görüntülenmeyecektir.
LogAssertion metodunun ikinci parametresi, hatayı açıklayan bir string değeridir. Bu parametre, hatanın nedenini açıklamak için kullanılır. Eğer bu parametre belirtilmezse, hata mesajı varsayılan bir mesajla oluşturulur.
LogAssertion metodu, Debug.Assert metodundan farklı olarak, hata mesajını otomatik olarak kesintiye uğratmaz. Bunun yerine, hatanın hemen ardından program devam eder.
LogAssertionFormat Metodu
Unity oyun motorunda Debug sınıfının LogAssertionFormat metodu, LogAssertion metoduna benzer şekilde çalışır, ancak hata mesajını özelleştirmek için formatlama seçeneği sunar.
Metod, birinci parametre olarak bir boolean değer alır ve eğer bu değer “false” ise, ikinci parametre olarak belirtilen formatlanmış hata mesajını ve gerekirse ekstra argümanları konsola yazar. Eğer boolean değer “true” ise, hiçbir şey yapılmaz ve program normal şekilde devam eder.
Örnek kullanımı aşağıdaki gibidir:
int x = 5;
int y = 10;
Debug.LogAssertionFormat(x == y, "x ({0}) should be equal to y ({1})", x, y);
Bu kod, x’in y’ye eşit olmadığı durumda “x (5) should be equal to y (10)” mesajını konsola yazar ve program devam eder. Tersi durumda herhangi bir mesaj yazılmaz ve program normal şekilde devam eder.
Not: LogAssertionFormat metodu, string formatlama için C# formatlama syntax’ını kullanır. Bu nedenle, örneğin, “{0:N2}” gibi string formatlama syntax’ı kullanarak sayıları belirli bir formatta yazdırabilirsiniz.
LogError Metodu
Unity oyun motorunda Debug sınıfında yer alan LogError metodu, hata oluştuğunda hata mesajını ve stack trace’ı konsola yazdırmak için kullanılır. Bu sayede hata ayıklama sürecinde nerede ve ne zaman hata oluştuğu daha kolay bir şekilde belirlenebilir.
Metodun imzası şu şekildedir:
public static void LogError(object message); public static void LogError(string tag, object message);
İlk parametre olan message hatayla ilgili bir mesajdır ve isteğe bağlıdır. İkinci parametre olan tag ise hatayı gruplamak için kullanılabilir.
Örnek olarak, bir oyun sahnesindeki bir nesneyi etkileşimli hale getiren bir script yazdığımızı varsayalım. Ancak script çalışmadığı için nesneyle etkileşim kuramıyoruz. Bu durumda, Debug.LogError metodu kullanarak hatanın nerede oluştuğunu ve neden kaynaklandığını konsola yazdırabiliriz:
void Start()
{
if (GetComponent<Rigidbody>() == null)
{
Debug.LogError("Bu script Rigidbody bileşenine ihtiyaç duyar");
}
}
Bu örnekte, scriptin çalışması için Rigidbody bileşenine ihtiyaç duyulduğu için, bileşenin bu script tarafından erişilemediği durumunda bir hata mesajı yazdırılıyor.
LogErrorFormat Metodu
Debug.LogErrorFormat() metodu, hata mesajlarının ve ek bilgilerin biçimlendirilerek gösterilmesini sağlayan bir yöntemdir. Bu metot, LogError() metodu gibi bir hata mesajı gösterir, ancak ek olarak bir formatlama dizesi ve argümanlar alır.
Metodun imzası şu şekildedir:
public static void LogErrorFormat(string format, params object[] args);
- format: Biçimlendirilmiş hata mesajını belirten dize.
- args: Biçimlendirilecek parametrelerin dizisi.
Örnek kullanımı:
int x = 3;
int y = 0;
if (y == 0) {
Debug.LogErrorFormat("Division by zero: x={0}, y={1}", x, y);
}
Bu örnekte, y değişkeninin değeri sıfır olduğu için bir bölme işlemi gerçekleştirilemez. Bu durumda, LogErrorFormat() yöntemi kullanılarak bir hata mesajı oluşturulur. Format dizesindeki {0} ve {1} yer tutucuları, args dizisindeki ilgili argümanlarla değiştirilir. Böylece, çıktı “Division by zero: x=3, y=0” şeklinde olacaktır.
LogException Metodu
Unity oyun motorunda Debug sınıfı içinde yer alan LogException metodu, bir istisna ya da hata nesnesi belirtilerek, bu hatanın neden kaynaklandığını ve hatanın oluştuğu satır ve dosya bilgilerini yazdırmak için kullanılır. Bu metot, hata raporlama işleminin daha ayrıntılı ve kapsamlı bir şekilde yapılmasını sağlar.
Aşağıda bir örnek kullanım gösterilmiştir:
try {
// Hata oluşabilecek bir kod bloğu
}
catch (Exception ex) {
Debug.LogException(ex);
}
Yukarıdaki örnekte, bir hata oluşabilecek kod bloğu try-catch bloğu içinde yer alır. Eğer bu kod bloğunda bir hata meydana gelirse, catch bloğu çalışacak ve hatanın neden kaynaklandığını, hatanın hangi satır ve dosyada meydana geldiğini belirterek hatayı ayrıntılı bir şekilde raporlayacaktır. Bu sayede, hata oluştuğunda hatanın kaynağı daha hızlı bir şekilde tespit edilebilir ve giderilebilir.
LogFormat Metodu
Unity oyun motorunda Debug sınıfında yer alan LogFormat metodu, bir dize biçimlendirme özelliğini kullanarak hata ayıklama bilgilerini yazdırmak için kullanılır. Bu yöntem, belirtilen biçimlendirme dizesindeki yer tutuculara göre log mesajı oluşturur.
LogFormat metodu, Log ve LogWarning metodlarına benzer şekilde çalışır, ancak daha özelleştirilebilir bir mesaj biçimi sunar. Bu yöntem, Debug.Log veya Debug.LogWarning yöntemleriyle yazdırılan mesajların yerine kullanılabilir.
LogFormat metodu, iki parametre alır: bir biçimlendirme dizesi ve değiştirilecek öğelerin bir listesi. Biçimlendirme dizesi, yazdırılacak mesajın formatını belirler ve öğeler listesi, yer tutucuların yerine geçecek öğeleri içerir.
Aşağıda bir örnek verilmiştir:
int score = 100;
string playerName = "John";
Debug.LogFormat("Congratulations, {0}! Your score is {1}.", playerName, score);
Bu örnek, “Congratulations, John! Your score is 100.” mesajını yazdırır.
Burada, biçimlendirme dizesinde iki yer tutucu kullanıldı: {0} ve {1}. İlk yer tutucu, playerName değişkeninin değeriyle, ikinci yer tutucu ise score değişkeninin değeriyle değiştirildi. Bu yöntem, bir dizeyi oluşturmak ve yer tutuculara göre özelleştirmek için çok kullanışlıdır.
LogWarning Metodu
Unity oyun motorunda Debug sınıfında yer alan LogWarning metodu, uyarı mesajları oluşturmak için kullanılır. Bu metot, konsol penceresinde sarı renkte ve “Warning” etiketiyle birlikte görüntülenen mesajları yazdırır. Bu sayede, geliştiriciler kodlarında bir uyarıya dikkat çekebilir veya bir hata oluşmadan önce potansiyel problemleri belirleyebilirler.
LogWarning metodu şu şekildedir:
public static void LogWarning(string message);
Bu metot, bir string parametresi alır ve bu parametreyi konsol penceresinde görüntüler. Örneğin, aşağıdaki örnek kodda, “Değer null” uyarısı LogWarning metodu kullanılarak yazdırılır:
string deger = null;
if (deger == null)
{
Debug.LogWarning("Değer null");
}
Bu kodda, deger değişkeni null olduğu için koşul ifadesi doğrudur ve Debug.LogWarning metodu çağrılır. Bu metot, “Değer null” uyarısı ile birlikte sarı renkte ve “Warning” etiketiyle birlikte konsol penceresinde görüntülenir.
LogWarningFormat Metodu
Unity oyun motorunda Debug sınıfında yer alan LogWarningFormat metodu, parametre olarak verilen bir format dizesi ve belirtilen argümanları kullanarak bir uyarı mesajı gösterir. Bu metot, LogFormat metodu gibi çalışır, ancak mesajın önem derecesi “Warning” olarak belirtilir.
Metodun imzası şöyledir:
public static void LogWarningFormat(string format, params object[] args);
Burada, format parametresi, mesajı biçimlendirmek için kullanılan bir format dizesidir ve args parametresi ise format dizesinde yer alan öğelerin değerlerini içeren bir dizi argümandır.
Örnek kullanımı:
int playerScore = 100;
string playerName = "John";
Debug.LogWarningFormat("Player {0} scored {1} points.", playerName, playerScore);
Bu örnekte, “Player John scored 100 points.” şeklinde bir uyarı mesajı görüntülenecektir.
Debug Sınıfı Özellikleri (Static Properties)
developerConsoleVisible Özelliği
Unity’de Debug sınıfı, geliştiricilerin uygulamalarının farklı noktalarında yazdıkları mesajları konsol üzerinde görmelerine yardımcı olan bir sınıftır. Bu sınıfın içerisinde developerConsoleVisible isimli bir Static Property bulunur.
developerConsoleVisible, geliştiricilerin konsolun görünürlüğünü kontrol etmelerini sağlar. Bu property sayesinde, konsolun açık veya kapalı olmasını kontrol edebilirsiniz. Eğer bu property true değerine sahipse, konsol görünür olacak, false değerine sahipse de konsol gizli olacaktır.
Aşağıda örnek bir kullanım senaryosu verilmiştir:
using UnityEngine;
public class Example : MonoBehaviour
{
void Start()
{
Debug.Log("Oyun başladı");
Debug.Log("Developer konsolu açık mı? " + Debug.developerConsoleVisible);
Debug.Log("Oyun devam ediyor...");
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
Debug.developerConsoleVisible = !Debug.developerConsoleVisible;
Debug.Log("Developer konsolu açık mı? " + Debug.developerConsoleVisible);
}
}
}
Yukarıdaki örnekte, Start() metodunda “Oyun başladı”, “Developer konsolu açık mı?” ve “Oyun devam ediyor…” mesajları Debug.Log() metodu kullanılarak konsol üzerinde görüntülenmektedir. Ayrıca Update() metodunda, space tuşuna basıldığında developerConsoleVisible property’sinin değeri tersine çevrilmekte ve bu durum “Developer konsolu açık mı?” mesajı ile konsol üzerinde gösterilmektedir.
isDebugBuild Özelliği
Unity’nin Debug sınıfında yer alan isDebugBuild Static Property’si, projenin debug modunda çalışıp çalışmadığını kontrol etmek için kullanılır. Bu özellik, Unity Editörü’nde “Development Build” seçeneğinin etkinleştirilip etkinleştirilmediğini kontrol eder.
Eğer proje debug modunda çalışıyorsa, bu özellik true değerini döndürür. Aksi takdirde, false değerini döndürür.
İşlevsel olarak, bu özelliklerin kullanımı, projenin performansını etkilemez. Bunun yerine, proje hatalarını gidermek ve hata ayıklama sırasında yararlı olur.
Aşağıda bir örnek verilmiştir:
using UnityEngine;
public class DebugBuildExample : MonoBehaviour
{
void Start()
{
if (Debug.isDebugBuild)
{
Debug.Log("Projemiz debug modunda çalışıyor!");
}
else
{
Debug.Log("Projemiz release modunda çalışıyor!");
}
}
}
Bu örnekte, isDebugBuild özelliği, projenin debug modunda çalışıp çalışmadığını kontrol eder. Eğer projemiz debug modunda çalışıyorsa, “Projemiz debug modunda çalışıyor!” metni konsola yazdırılır. Aksi takdirde, “Projemiz release modunda çalışıyor!” metni konsola yazdırılır.
unityLogger Özelliği
Unity oyun motorunda Debug sınıfında yer alan unityLogger Static Properties, Debug sınıfının altındaki metotların kullandığı varsayılan Unity Log sistemi yerine başka bir loglama sistemi kullanmak isteyenler için bir seçenek sunar.
Bu özellik, ILogger arayüzünü uygulayan bir nesne döndürür. ILogger, Unity’nin varsayılan loglama sistemine bir alternatif olarak tanıtılan genel bir loglama arayüzüdür. unityLogger Static Properties, ILogger arayüzünü uygulayan bir nesne döndürür. Bu nesne üzerinden farklı bir loglama sistemi kullanarak özelleştirilmiş bir loglama çözümü oluşturulabilir.
Örneğin, Debug sınıfının varsayılan loglama sistemine ek olarak bir yazma sistemi eklemek isteyebilirsiniz. unityLogger Static Properties, ILogger arayüzünü uygulayan bir nesne döndürdüğü için bu nesne üzerinden bir yazma sistemi ekleyebilirsiniz.
Örnek olarak, aşağıdaki kod unityLogger Static Properties kullanarak yeni bir loglama sistemi ekler:
using UnityEngine;
using UnityEngine.ILogger;
public class MyLogger : ILogger
{
public void Log(LogType logType, string message)
{
// Yeni loglama sistemi burada yazılabilir.
}
// Diğer ILogger metotları burada yer alır.
}
public class Example : MonoBehaviour
{
private void Start()
{
// Yeni logger oluşturuluyor.
ILogger myLogger = Debug.unityLogger;
// Unity'nin varsayılan loglama sistemi değiştiriliyor.
Debug.unityLogger = new MyLogger();
}
}
Bu örnekte, MyLogger adlı yeni bir loglama sistemi oluşturuldu ve unityLogger Static Properties kullanılarak Debug sınıfındaki varsayılan loglama sistemi değiştirildi. Bu sayede, artık Debug sınıfındaki tüm metotlar MyLogger üzerinden çalışacak ve yeni loglama sistemi kullanılacaktır.
