Lesen Sie weiter, um zu erfahren, wie Sie Ihren QA- und Debugging-Prozess mit der Debug-Klasse von Unity verbessern können.
Während Sie möglicherweise bereits mit der Debug.Log Funktion vertraut sind, unterstützt die Unity Debug-Klasse viele andere nützliche Funktionen, die Ihnen helfen können, Ihre Tests und Debugging zu beschleunigen. Diese Seite erklärt, wie Sie die Debug-Klasse für die Gizmo-Visualisierung in den Szenen- und Spielansichten verwenden, um den Spielmodus im Editor per Skript zu pausieren und weitere Tipps.
Wenn Sie Erfahrung mit Unity haben, haben Sie wahrscheinlich das Konsole-Fenster verwendet, um Fehler, Warnungen und andere vom Editor generierte Nachrichten anzuzeigen. Sie haben sicherlich auch Ihre eigenen Nachrichten an die Konsole mit der Debug Klasse ausgegeben.
Aber Sie sind nicht nur auf die Debug.Log-Nachricht beschränkt. Wenn Sie Ausgabestrings im Konsolenfenster erstellen, können Sie einen von drei Typen (Fehler, Warnung und Nachricht) angeben, jeder mit seinem eigenen Symboltyp.
Die drei Varianten sind:
Sie können das Konsolenfenster verwenden, um die Nachrichten basierend auf Ihren Vorlieben zu filtern. Sie können auch die Fehlerpause im Konsolenfenster nutzen, da alle Fehler, die Sie über die Debug-Klasse in die Konsole schreiben, den Spielmodus von Unity anhalten.
Alles, was im Konsolenfenster ausgegeben wird, sei es von Unity oder Ihren eigenen Nachrichten, wird in einer Protokolldatei hinzugefügt, auf die Sie verweisen können, um zu sehen, wo Probleme in Ihrer Anwendung aufgetreten sind. Jedes Betriebssystem speichert die Protokolldateien an unterschiedlichen Orten, also überprüfen Sie die Dokumentation, um die Spezifikationen für jedes System zu sehen.
Wenn ein Fehler oder eine Ausnahme ausgelöst wird, zeigt das Konsolenfenster den Stack-Trace zusammen mit der Fehlermeldung an, um Ihnen zu helfen, zu verstehen, wie der Fehler aufgetreten ist und wo er seinen Ursprung hat. Während Debug.Log es Ihnen ermöglicht, eine Nachricht an die Konsole zu senden, können Sie auch das Detailniveau konfigurieren, das im Stack-Trace angezeigt wird.
Standardmäßig verlinkt die Ausgabe in der Konsole zur Codezeile, die die Nachricht generiert hat, was es einfach macht, die Zeile, Methode oder Sequenz von Funktionsaufrufen zu identifizieren, die den Eintrag verursacht haben.
Wenn das Skript nicht in Ihrer gewählten IDE geöffnet wird, gehen Sie zu Datei > Einstellungen > Externe Tools und wählen Sie den „Externen Skripteditor“ aus dem Dropdown-Menü aus.
Sie können die Informationen, die im Stack-Trace angezeigt werden, über Datei > Build-Einstellungen… > Spieler-Einstellungen… > Weitere Einstellungen im Editor konfigurieren.
Die folgenden Optionen stehen für jeden Protokolltyp zur Verfügung:
Nutzen Sie die Suchfunktion in der Konsole, wenn Ihr Protokoll überfüllt wird. Während Sie einen Suchbegriff eingeben, filtert die Konsole die Nachrichten, um nur die anzuzeigen, die den übereinstimmenden Text enthalten.
Steuern Sie, wie viele Zeilen jedes Eintrags in der Liste sichtbar sind, indem Sie auf die Schaltfläche des Konsolenmenüs klicken und Log Entry > [X] Zeilen aus dem Menü auswählen, wobei [X] die Anzahl der anzuzeigenden Zeilen für jeden Eintrag ist.
Die String.Format Methode in C# ermöglicht es Ihnen, einen String mit eingebetteten formatierten Variablen-Daten zu erstellen. Die Debug-Klasse hat Debug.LogFormat, die dieselbe Syntax verwendet.
Der erste Parameter ist der formatierte Nachrichtenstring. Durch das Einfügen eines Indexwerts in geschweifte Klammern wird dieser durch den Parameterindex-1 unter Verwendung seiner ToString Methode ersetzt, falls vorhanden, oder durch die System-String-Konvertierung. Im obigen Codebeispiel wird in Zeile 14 {0} durch origin.ToString() ersetzt.
Ein komplexeres Beispiel ist dieses:
Debug.LogFormat("Zu Beginn transform.position={0}, transform.rotation={1}", transform.position, transform.rotation);
{0} wird durch Parameter 1, transform.position, und {1} wird durch Parameter 2, transform.rotation, ersetzt. In jedem Fall wird die ToString-Methode der Vector3- und Quaternion-Eigenschaften verwendet. Das Ergebnis wird so aussehen:
„Der Ursprung ist (0.00, 0.00, 0.00)
UnityEngine.Debug:LogFormat (string,object[])“
Sie können auch einen optionalen zweiten Parameter für diese Protokollmethoden angeben, um anzuzeigen, dass die Nachricht mit einem bestimmten GameObject verbunden ist:
Debug.LogWarning("Ich komme in Frieden!", this.gameObject);
Wenn Sie formatierte Variablen-Daten anzeigen, gibt es Warnungs- und Fehlerversionen von Debug.LogFormat:
Wenn Sie einen Float-Wert an die Konsole mit Debug.Logformat senden, wird die Standardanzeige sechs Zahlen nach dem Dezimalpunkt anzeigen. Sie können dieses Verhalten mit einer benutzerdefinierten numerischen Formatzeichenfolge steuern.
Debug.LogFormat("pi = {0:0.00}", Mathf.PI);
Durch die Verwendung eines Doppelpunktes zeigt die Formatzeichenfolge 0.00 den ganzzahligen Teil eines Wertes, das Dezimaltrennzeichen und zwei Zahlen nach dem Trennzeichen an. Die letzte Zahl wird basierend auf dem nächsten Wert mit der bekannten Methode gerundet: 4 zum Boden, 5 zum Himmel.
In diesem Beispiel wäre die Ausgabe: pi = 3.14
So führen Sie automatisierte Tests für Ihre Spiele mit dem Unity Test Framework aus
Debug.Assert() ist ähnlich wie die Methode Debug.Log(), aber anstatt eine Nachricht in die Konsole zu protokollieren, testet es eine Bedingung und zeigt eine Fehlermeldung an, wenn die Bedingung falsch ist. Es wird verwendet, um Annahmen zu validieren und Fehler während der Entwicklung zu erkennen.
Assertions sind eine großartige Möglichkeit, um zu überprüfen, dass Ihr Programm keinen unerwarteten Zustand erreicht. Sie sind wie das Einbetten eines Logs in eine if-Anweisung. Wenn Sie an einer Methode arbeiten, die davon abhängt, dass eine Klassenproperty zugewiesen ist, kann eine Assertion Ihnen helfen, Fehler zu finden.
Wenn Debug.Assert() aufgerufen wird, nimmt es zwei Parameter: eine zu testende Bedingung und eine optionale Nachricht, die angezeigt wird, wenn die Bedingung falsch ist. Wenn die Bedingung wahr ist, passiert nichts und das Programm läuft weiter. Wenn die Bedingung falsch ist, stoppt das Programm und eine Fehlermeldung wird im Editor angezeigt.
void SetColor(Color color)
{
Debug.Assert(material != null, "ChangeColor: material nicht zugewiesen");
material.SetColor("_Color", color);
}
Wenn Sie SetColor aufrufen und material nicht zugewiesen ist, wird 'SetColor: material nicht zugewiesen' in der Konsole angezeigt.
Debug.Break() ist eine Methode der Debug-Klasse von Unity, die verwendet wird, um die Ausführung Ihres Spiels anzuhalten und den Debugger an der aktuellen Stelle in Ihrem Code zu betreten. Es ermöglicht Ihnen, den Zustand Ihres Spiels zu inspizieren und Ihren Code zeilenweise durchzugehen, um Fehler zu finden und zu beheben.
Wenn Debug.Break() aufgerufen wird, stoppt es die Ausführung Ihres Spiels und öffnet das Debugger-Fenster. Dies ermöglicht es Ihnen, den Zustand Ihres Spiels zu überprüfen und Ihren Code nach Bedarf zu debuggen. Sie können den Debugger verwenden, um Ihren Code durchzugehen, Haltepunkte zu setzen und Variablen und Objekte im Speicher zu inspizieren.
Zum Beispiel möchten Sie möglicherweise ein Spiel anhalten, wenn ein NPC innerhalb der Zielreichweite des Spielercharakters ist. Wenn das Spiel stoppt, können Sie seinen Zustand im Inspektor überprüfen:
float dist = Vector3.Distance(transform.position, npc.position);
if ( dist < 5) Debug.Break();
Debug.DrawLine und Debug.DrawRay sind zwei Methoden der Debug-Klasse von Unity, die für visuelles Debugging verwendet werden. Sie sind nützlich, um physikbezogenen Code zu testen und zu visualisieren, wie Kollisionen und Strahlen. Beide ermöglichen es Ihnen, eine farbige Linie zu zeichnen, die sowohl in der Spiel- als auch in der Szenenansicht sichtbar ist. Zum Beispiel können Sie Debug.DrawRay verwenden, um die Trajektorie einer Kugel oder den Pfad eines Laserstrahls zu visualisieren, und Debug.DrawLine verwenden, um die Grenzen eines Colliders oder die Bewegung eines Objekts zu visualisieren.
Debug.DrawLine wird verwendet, um eine gerade Linie zwischen zwei Punkten in der Szene zu zeichnen:
Debug.DrawLine(transform.position, target.position, Color.white, 0, false);
Es nimmt zwei bis fünf Parameter: einen Startpunkt, einen Endpunkt und eine optionale Farbe. Zum Beispiel würde der folgende Code eine weiße Linie zwischen den Punkten start und end zeichnen:
public static void DrawLine(Vector3 start, Vector3 end, Color color = Color.white, float duration = 0.0f, bool depthTest = true);
Parameter
Im Codebeispiel führt die Update-Methode eines MonoBehaviour-Skripts, das am Skeleton GameObject angehängt ist, zu dem oben gesehenen Bild. Die Linie ist nur im Spielansichtsmodus sichtbar, wenn Gizmos aktiviert sind. Klicken Sie auf die Gizmo-Schaltfläche oben rechts im Spielansichtsfenster, um sie zu aktivieren. Die Linie ist auch im Szenenansichtsmodus sichtbar.
Die Alternative zu DrawLine ist DrawRay. Debug.DrawRay wird verwendet, um einen Strahl in der Szene zu zeichnen, der von einem bestimmten Ursprung ausgeht und in eine bestimmte Richtung verläuft. Standardmäßig ist es ein unendlicher Strahl. Wenn der von Debug.DrawRay() gezeichnete Strahl auf einen Collider trifft, stoppt er an dem Schnittpunkt und wird nicht weiter fortgesetzt. Dieses Verhalten ist dasselbe wie das eines Raycasts in Unity, der verwendet wird, um Kollisionen zwischen Objekten in einer Szene zu erkennen.
Hier definiert der zweite Parameter eine Richtung und Länge der Linie. Die Linie wird von start bis start + dir gezeichnet:
public static void DrawRay(Vector3 start, Vector3 dir, Color color = Color.white, float duration = 0.0f, bool depthTest = true);
Die Parameter im Codebeispiel sind:
Hier ist ein weiteres Codebeispiel:
Vector3 dir = transform.TransformDirection(Vector3.forward) * 3;Debug.DrawRay(transform.position, dir, Color.white, 0, false);
In diesem Codebeispiel führt die Update-Methode eines MonoBehaviour-Skripts, das am Skeleton GameObject angehängt ist, zu dem oben gezeigten Bild. Ein Ray mit einer Länge kann nützlich sein, um Nähe-Tests zu debuggen. Hier beträgt die Ray-Länge 3 Welt-Einheiten. Wenn ein Angriff bei 3 Einheiten beginnen soll, haben Sie einen großartigen visuellen Test dafür, wie lang 3 Einheiten in Ihrer Szene sind.
Tipps zum Testen und zur Qualitätssicherung für Unity-Projekte
Gizmos sind ein leistungsstarkes Werkzeug für visuelles Debugging in Unity. Sie ermöglichen es Ihnen, einfache 2D- und 3D-Formen, Linien und Text in der Szenenansicht zu zeichnen, was es einfach macht zu sehen und zu verstehen, was in Ihrer Spielwelt passiert.
Sie können einfache Formen und Linien in der Szenenansicht mit nur wenigen Codezeilen zeichnen. Dies macht sie zu einem idealen Werkzeug, um schnell Prototypen zu erstellen und Ihre Spielmechaniken zu testen. Sie werden in Echtzeit gezeichnet, sodass Sie die Ergebnisse Ihrer Codeänderungen sofort sehen und notwendige Änderungen vornehmen können.
Gizmos zeigen visuell komplexe Spielmechaniken an, die durch Code allein schwer zu verstehen sein könnten. Zum Beispiel können Sie Gizmos verwenden, um eine Linie zu zeichnen, die den Pfad eines Projektils zeigt, oder um die Grenzen einer Triggerzone zu visualisieren, wie im obigen Bild zu sehen.
Verwenden Sie Gizmos, um visuelle Hilfen zu erstellen, die es anderen Teammitgliedern erleichtern, Ihren Code und die Spielmechaniken zu verstehen.
Gizmos haben wenig Einfluss auf die Leistung, sodass Sie sie frei verwenden können, ohne die Leistung zu beeinträchtigen.
Das Gizmo-Symbol befindet sich in der oberen rechten Ecke der Szenen- und Spielansichten. Um ein benutzerdefiniertes Gizmo hinzuzufügen, müssen Sie ein Skript hinzufügen, das einen OnDrawGizmos-Callback enthält, wie das folgende Codebeispiel zeigt. Dieses Skript zeichnet einen Drahtgitterwürfel, der 3 Welt-Einheiten vor der Position des GameObjects positioniert ist. Die Größe des Würfels wird durch die Klassen-Eigenschaft vsize des Typs Vector3 definiert: public Vector3 vsize = new Vector3(1f, 1f, 1f);
void OnDrawGizmos()
{
// Zeichne eine gelbe Kugel an der Position des Transforms
Gizmos.color = Color.yellow;
Vector3 position = transform.position + transform.TransformDirection(Vector3.forward) * 3;
Gizmos.DrawWireCube(position, vsize);
}
Steuern Sie die Sichtbarkeit, indem Sie auf das Gizmos-Dropdown klicken. Alle Skripte mit einem OnDrawGizmos-Callback werden aufgelistet.
Überprüfen Sie die Dokumentation, um mehr über andere nützliche Methoden der Gizmo-Klasse zu erfahren.
Das Auslösen einer Ausnahme ist eine Technik, die in der Programmierung verwendet wird, um anzuzeigen, dass während der Ausführung eines Programms ein Fehler oder eine außergewöhnliche Situation aufgetreten ist. Sie können diese Methode verwenden, um den Thread daran zu hindern, weiter auszuführen, um weiteren Schaden zu verhindern.
In Unity wird das Auslösen einer Ausnahme auf die gleiche Weise verwendet wie in anderen Programmiersprachen.
Wenn eine Ausnahme ausgelöst wird und im Code nicht abgefangen und behandelt wird, wird die Programmausführung normalerweise gestoppt und Sie werden aus der App und zurück zum Betriebssystem geworfen. In Unity wird die Programmausführung sofort gestoppt und die Laufzeitumgebung sucht nach einem "catch"-Block, der die Ausnahme behandeln kann. Wenn kein catch-Block gefunden wird, wird das Programm beendet und die Ausnahme wird in der Konsole protokolliert.
Das Auslösen von Ausnahmen kann hilfreich sein, da dies es Ihnen ermöglicht, die Fehlerbehandlungslogik von der restlichen Programmlogik zu trennen, was zur Erstellung sauberer Codes beitragen kann. Durch das Auslösen von Ausnahmen können Sie dem Aufrufer signalisieren, dass etwas schiefgelaufen ist, ohne sich auf Rückgabewerte oder globalen Zustand zur Kommunikation des Fehlers verlassen zu müssen.
Um eine Ausnahme in Unity auszulösen, können Sie das throw-Schlüsselwort gefolgt von einem Ausnahmeobjekt verwenden. Hier ist ein Beispiel:
if (target == null)
{
throw new System.NullReferenceException("target nicht gesetzt!");
}
Wenn Sie Ihren Code im Editor ausführen, fängt er die ausgelösten Fehler ab und führt anstelle eines Absturzes von Unity oder der App ein Debug.LogError() aus.
Die Verwendung von Ausnahmen in Unity ermöglicht es Ihnen, Fehler frühzeitig zu erkennen. Es kann auch das Debuggen erleichtern, indem es Ihnen mehr Informationen darüber gibt, wo Fehler auftreten und was sie verursacht hat.
Erfahren Sie viel mehr über Testen, Debuggen und die Verbesserung der Leistung Ihres Unity-Projekts in diesen Artikeln:
Tauchen Sie mit diesen E-Books in fortgeschrittene Best Practices und Anleitungen für Unity-Entwickler ein:
Finden Sie viele weitere fortgeschrittene Ressourcen im Unity Best Practices Hub.
