Wenn Sie Erfahrung mit Unity haben, dann haben Sie wahrscheinlich das Konsolenfenster verwendet, um Fehler, Warnungen und andere vom Editor generierte Meldungen anzuzeigen. Sicherlich haben Sie auch Ihre eigenen Meldungen mit Hilfe der Debug-Klasse auf der Konsole ausgegeben.

Aber Sie sind nicht nur auf die Debug.Log Message beschränkt. Wenn Sie die Ausgabe von Zeichenketten in das Konsolenfenster erstellen, können Sie einen von drei Typen (Fehler, Warnung und Meldung) angeben, die jeweils einen eigenen Symboltyp haben.

Die drei Varianten sind:

• Debug.Log ("Dies ist eine Protokollmeldung.")
• Debug.LogWarning ("Dies ist eine Warnmeldung.")
• Debug.LogError ("Dies ist eine Fehlermeldung.")

Sie können das Konsolenfenster verwenden, um die Nachrichten nach Ihren Wünschen zu filtern. Sie können auch den Vorteil nutzen, dass die Fehlerpause im Konsolenfenster aktiviert ist, da alle Fehler, die Sie über die Debug-Klasse in die Konsole schreiben, dazu führen, dass der Spielmodus von Unity pausiert.

Alles, was im Konsolenfenster ausgegeben wird, entweder von Unity oder von Ihren eigenen Meldungen, wird zu einer Protokolldatei hinzugefügt, in der Sie nachsehen können, wo in Ihrer Anwendung Probleme aufgetreten sind. Jedes Betriebssystem speichert die Protokolldateien an einem anderen Ort. Informieren Sie sich daher in der Dokumentation über die Spezifikationen des jeweiligen Systems.

Wenn ein Fehler oder eine Ausnahme ausgelöst wird, zeigt das Konsolenfenster die Stapelverfolgung zusammen mit der Fehlermeldung an, damit Sie verstehen können, wie der Fehler aufgetreten ist und wo er seinen Ursprung hat. Mit Debug.Log können Sie nicht nur eine Meldung an die Konsole senden, sondern auch den Detaillierungsgrad des Stacktrace konfigurieren.

Standardmäßig ist die Ausgabe in der Konsole mit der Codezeile verknüpft, die die Meldung erzeugt hat, so dass die Zeile, Methode oder Folge von Funktionsaufrufen, die den Eintrag verursacht haben, leicht zu identifizieren ist.

Wenn das Skript nicht in der von Ihnen gewählten IDE geöffnet wird, gehen Sie zu Datei > Voreinstellungen > Externe Werkzeuge und wählen Sie den "Externen Skript-Editor" aus dem Dropdown-Menü.

Sie können die im Stack-Trace angezeigten Informationen über Datei > Build-Einstellungen ... > Player-Einstellungen ... > Andere Einstellungen im Editor konfigurieren.

Die folgenden Optionen sind für jeden Protokolltyp verfügbar:

• Keine: Es wird kein Stack-Trace im Protokoll ausgegeben.
• ScriptOnly: Es wird nur der verwaltete Stacktrace ausgegeben. Dies ist die Standardoption, wenn Sie die Einstellungen nicht geändert haben.
• Vollständig: Native und verwaltete Stack Traces werden protokolliert.

Benutzen Sie die Suchfunktion in der Konsole, wenn Ihr Protokoll überfüllt ist. Wenn Sie einen Suchbegriff eingeben, filtert die Konsole die Nachrichten so, dass nur diejenigen angezeigt werden, die den passenden Text enthalten.

Legen Sie fest, wie viele Zeilen jedes Eintrags in der Liste sichtbar sind, indem Sie auf die Schaltfläche Konsole klicken und im Menü Protokolleintrag > [X] Zeilen wählen, wobei [X] die Anzahl der Zeilen ist, die für jeden Eintrag angezeigt werden sollen.

Die String.Format Methode in C# ermöglicht es Ihnen, eine Zeichenkette mit eingebetteten formatierten variablen Daten zu erstellen. Die Debug-Klasse hat Debug.LogFormatdie dieselbe Syntax verwendet.

Der erste Parameter ist die formatierte Zeichenfolge der Nachricht. Wenn Sie einen Indexwert in geschweifte Klammern einschließen, wird dieser durch den Parameter index-1 ersetzt, indem Sie seine ToString-Methode, falls vorhanden, oder die System-String-Konvertierung verwenden. Im obigen Codebeispiel, Zeile 14, wird {0} durch origin.ToString() ersetzt.

Ein komplexeres Beispiel ist dieses:

Debug.LogFormat("Beim Start transform.position={0}, transform.rotation={1}", transform.position, transform.rotation);

{0} wird durch den Parameter 1, transform.position, und {1} wird durch den Parameter 2, transform.rotation, ersetzt. In jedem Fall wird die Methode ToString der Eigenschaften Vector3 und Quaternion verwendet. Das Ergebnis sieht dann so aus:

"Der Ursprung ist (0.00, 0.00, 0.00)

UnityEngine.Debug:LogFormat (string,object[])”

Sie können diesen Log-Methoden auch einen optionalen zweiten Parameter hinzufügen, um anzugeben, dass die Nachricht mit einem bestimmten GameObject verbunden ist:

Debug.LogWarning("Ich komme in Frieden!", this.gameObject);

Wenn Sie formatierte Variablendaten anzeigen, gibt es Warn- und Fehlerversionen von Debug.LogFormat:

• Debug.LogWarningFormat("Der Wert von Würfel.Position.x ist {0:0.00}", transform.Position.x)
• Debug.LogErrorFormat("Der Wert von Würfel.Position.x ist {0:0.00}", transform.Position.x)

Wenn Sie mit Debug.Logformat einen Float-Wert an die Konsole senden, werden standardmäßig sechs Zahlen nach dem Dezimalpunkt angezeigt. Sie können dieses Verhalten mit einer benutzerdefinierten numerischen Formatierungszeichenfolge steuern.

Debug.LogFormat("pi = {0:0.00}", Mathf.PI);

Durch die Verwendung eines Doppelpunktes zeigt die Formatierungszeichenfolge 0.00 den ganzzahligen Teil eines Wertes, das Dezimaltrennzeichen und zwei Zahlen nach dem Trennzeichen an. Die letzte Zahl wird auf der Grundlage des nächsten Wertes nach der bekannten Methode gerundet: 4 auf den Boden, 5 in den Himmel.

In diesem Beispiel würde die Ausgabe lauten: pi = 3,14

Wie man mit dem Unity Test Framework automatisierte Tests für seine Spiele durchführt

Debug.Assert() ähnelt der Methode Debug.Log(), aber anstatt eine Nachricht auf der Konsole zu protokollieren, wird eine Bedingung getestet und eine Fehlermeldung angezeigt, wenn die Bedingung falsch ist. Sie dient dazu, Annahmen zu überprüfen und Fehler während der Entwicklung zu erkennen.

Assertions sind eine gute Möglichkeit zu überprüfen, dass Ihr Programm nicht in einen unerwarteten Zustand gerät. Sie sind wie die Einbettung eines Protokolls in eine if-Anweisung. Wenn Sie an einer Methode arbeiten, die von der Zuweisung einer Klasseneigenschaft abhängt, kann eine Assertion Ihnen helfen, Fehler zu finden.

Beim Aufruf von Debug.Assert() werden zwei Parameter übergeben: eine zu testende Bedingung und eine optionale Meldung, die angezeigt werden soll, wenn die Bedingung falsch ist. Wenn die Bedingung erfüllt ist, passiert nichts und das Programm läuft weiter. Wenn die Bedingung falsch ist, wird das Programm angehalten und eine Fehlermeldung im Editor angezeigt.

void SetColor(Farbe color)

{

Debug.Assert(material != null, "ChangeColor: material not assigned");

material.SetColor("_Color", color);

}

Wenn Sie SetColor aufrufen und das Material nicht zugewiesen ist, wird in der Konsole 'SetColor: Material nicht zugewiesen' angezeigt.

Debug.Break() ist eine Methode, die von der Debug-Klasse von Unity zur Verfügung gestellt wird. Sie wird verwendet, um die Ausführung des Spiels anzuhalten und den Debugger an der aktuellen Stelle des Codes zu starten. Damit können Sie den Zustand Ihres Spiels überprüfen und Ihren Code Zeile für Zeile durchgehen, um Fehler zu finden und zu beheben.

Wenn Debug.Break() aufgerufen wird, hält es die Ausführung des Spiels an und öffnet das Debugger-Fenster. So können Sie den Zustand Ihres Spiels überprüfen und Ihren Code bei Bedarf debuggen. Mit dem Debugger können Sie schrittweise durch Ihren Code gehen, Haltepunkte setzen und Variablen und Objekte im Speicher untersuchen.

Zum Beispiel kann man ein Spiel anhalten, wenn sich ein NSC in der Nähe des Spielercharakters befindet. Wenn das Spiel unterbrochen wird, können Sie seinen Zustand im Inspektor überprüfen:

float dist = Vector3.Distance(transform.position, npc.position);

wenn ( dist < 5) Debug.Break();

Debug.DrawLine und Debug.DrawRay sind zwei Methoden der Debug-Klasse von Unity, die für das visuelle Debugging verwendet werden. Sie sind nützlich, um physikbezogenen Code zu testen und zu visualisieren, z. B. Kollisionen und Raycasts. Mit beiden können Sie eine farbige Linie zeichnen, die sowohl in der Spiel- als auch in der Szenenansicht sichtbar ist. Sie können zum Beispiel Debug.DrawRay verwenden, um die Flugbahn eines Geschosses oder den Weg eines Laserstrahls zu visualisieren, und Debug.DrawLine verwenden, um die Grenzen eines Kolliders 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);

Sie benötigt zwei bis fünf Parameter: einen Startpunkt, einen Endpunkt und eine optionale Farbe. Der folgende Code würde zum Beispiel eine weiße Linie zwischen den Punkten Start und Ende zeichnen:

public static void DrawLine(Vector3 start, Vector3 end, Color color = Color.white, float duration = 0.0f, bool depthTest = true);

Parameter

• beginnen: Punkt im Weltraum, an dem die Linie beginnen soll
• Ende: Punkt im Weltraum, an dem die Linie enden soll
• Farbe: Die Linienfarbe
• Dauer: Zeit in Sekunden für die Anzeige der Zeile. 0 zeigt Zeile für Einzelbild
• depthTest: Soll die Linie durch Vordergrundobjekte verdeckt werden

Im Codebeispiel ergibt die Update-Methode eines MonoBehaviour-Skripts, das an das Skeleton GameObject angehängt ist, das oben gezeigte Bild. Die Linie ist in der Spielansicht nur sichtbar, wenn Gizmos aktiviert sind. Klicken Sie auf die Schaltfläche Gizmo oben rechts im Spielfenster, um sie zu aktivieren. Die Linie ist auch in der Szenenansicht 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 sich in eine bestimmte Richtung erstreckt. Standardmäßig ist es ein unendlicher Strahl. Wenn der von Debug.DrawRay() gezeichnete Strahl auf einen Kollider trifft, wird er am Schnittpunkt angehalten und nicht weiter fortgesetzt. Dieses Verhalten entspricht dem eines Raycasts in Unity, der verwendet wird, um Kollisionen zwischen Objekten in einer Szene zu erkennen.

Hier definiert der zweite Parameter die Richtung und Länge der Linie. Die Linie wird von Anfang bis Anfang + 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:

• beginnen: Punkt im Weltraum, an dem die Linie beginnen soll
• dir: Richtung und Länge der Linie im Weltraum
• Farbe: Die Linienfarbe
• Dauer: Zeit in Sekunden für die Anzeige der Zeile; 0 zeigt Zeile für Einzelbild an
• depthTest: Soll die Linie durch Vordergrundobjekte verdeckt werden

Hier ist ein weiteres Codebeispiel:

Vector3 dir = transform.TransformDirection(Vector3.forward) * 3;Debug.DrawRay(transform.position, dir, Color.white, 0, false);

In diesem Codebeispiel ergibt die Update-Methode eines MonoBehaviour-Skripts, das an das Skeleton GameObject angehängt ist, das obige Bild. Ein Strahl mit einer Länge kann für die Fehlersuche bei Annäherungstests nützlich sein. Hier beträgt die Strahlenlänge 3 Welteinheiten. Wenn ein Angriff bei 3 Einheiten beginnen soll, dann haben Sie einen guten visuellen Test, wie lange 3 Einheiten in Ihrer Szene sind.

Tipps zum Testen und zur Qualitätssicherung für Unity-Projekte

Gizmos sind ein mächtiges Werkzeug für das visuelle Debugging in Unity. Sie ermöglichen es Ihnen, einfache 2D- und 3D-Formen, Linien und Text in der Szenenansicht zu zeichnen, so dass Sie leicht sehen und verstehen können, was in Ihrer Spielwelt passiert.

Sie können einfache Formen und Linien in der Szenenansicht mit nur wenigen Codezeilen zeichnen. Das macht sie zu einem idealen Werkzeug für das schnelle Prototyping und Testen Ihrer Spielmechanik. Sie werden in Echtzeit gezeichnet, so dass Sie die Ergebnisse Ihrer Code-Änderungen sofort sehen und die notwendigen Änderungen vornehmen können.

Gizmos weisen auf visuell komplexe Spielmechanismen hin, die durch Code allein schwer zu verstehen sind. Sie können Gizmos zum Beispiel verwenden, um eine Linie zu zeichnen, die den Weg eines Geschosses zeigt, oder um die Grenzen einer Auslösezone zu visualisieren, wie im Bild oben zu sehen.

Verwenden Sie Gizmos, um visuelle Hilfen zu erstellen, die es anderen Teammitgliedern erleichtern, Ihren Code und die Spielmechanik zu verstehen.

Gizmos haben nur geringe Auswirkungen auf die Leistung, so dass Sie sie frei verwenden können, ohne die Leistung zu verlangsamen.

Das Gizmo-Symbol befindet sich in der oberen rechten Ecke der Ansichten Szene und Spiel. 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 Welteinheiten vor der Position des GameObjects positioniert wird. Die Größe des Würfels wird durch die Klasseneigenschaft vsize vom Typ Vector3 definiert: public Vector3 vsize = new Vector3(1f, 1f, 1f);

void OnDrawGizmos()

{

// Zeichnen Sie eine gelbe Kugel an der Position der Transformation

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 Dropdown-Menü "Gizmos" klicken. Alle Skripte mit einem OnDrawGizmos-Callback werden aufgelistet.

Lesen Sie die Dokumentation, um mehr über andere nützliche Methoden mit der Gizmo-Klasse zu erfahren.

Das Auslösen einer Ausnahme ist eine Technik, die in der Programmierung verwendet wird, um anzuzeigen, dass ein Fehler oder eine Ausnahmesituation während der Ausführung eines Programms aufgetreten ist. Mit dieser Methode können Sie die weitere Ausführung des Fadens stoppen, um weitere Schäden zu vermeiden.

In Unity wird das Auslösen einer Ausnahme auf die gleiche Weise verwendet wie in anderen Programmiersprachen.

Wenn eine Ausnahme ausgelöst und nicht im Code abgefangen und behandelt wird, wird die Programmausführung in der Regel angehalten und Sie werden aus der Anwendung und zurück zum Betriebssystem geworfen. In Unity wird die Programmausführung sofort angehalten und die Laufzeitumgebung sucht nach einem "catch"-Block, der die Ausnahme behandeln kann. Wenn kein Catch-Block gefunden wird, bricht das Programm ab und die Ausnahme wird in der Konsole protokolliert.

Das Auslösen von Ausnahmen kann hilfreich sein, da Sie so die Fehlerbehandlungslogik vom Rest Ihrer Programmlogik trennen können, was zu einem saubereren Code beitragen kann. Durch das Auslösen von Ausnahmen können Sie dem Aufrufer signalisieren, dass etwas schief gelaufen ist, ohne dass Sie sich auf Rückgabewerte oder den globalen Zustand verlassen müssen, um den Fehler zu kommunizieren.

Um eine Ausnahme in Unity auszulösen, können Sie das Schlüsselwort throw gefolgt von einem Ausnahmeobjekt verwenden. Hier ist ein Beispiel:

if (Ziel == null)

{

throw new System.NullReferenceException("Ziel nicht gesetzt!");

}

Wenn Sie Ihren Code im Editor ausführen, fängt er die ausgelösten Fehler ab und führt ein Debug.LogError() aus, anstatt Unity oder die Anwendung zum Absturz zu bringen.

Die Verwendung von Exceptions in Unity ermöglicht es, Fehler frühzeitig abzufangen. Es kann auch die Fehlersuche erleichtern, da Sie mehr Informationen darüber erhalten, wo Fehler auftreten und wodurch sie verursacht werden.

In diesen Artikeln erfahren Sie mehr über das Testen, Debuggen und Verbessern der Leistung Ihres Unity-Projekts:

• Debuggen von Spielcode mit Roslyn Analyzers
• Wie man mit dem Unity Test Framework automatisierte Tests für seine Spiele durchführt
• Beschleunigen Sie Ihren Debugging-Workflow mit Microsoft Visual Studio Code
• Wie Sie Ihren Code mit Microsoft Visual Studio 2022 debuggen können
• Tipps zum Testen und zur Qualitätssicherung für Unity-Projekte

In diesen E-Books finden Sie fortgeschrittene Best Practices und Anleitungen für Unity-Entwickler:

• Ultimative Anleitung für die Profilerstellung für Unity-Spiele
• Optimieren Sie die Leistung Ihres Spiels für Mobilgeräte
• Optimieren Sie die Leistung Ihrer Konsolen- und PC-Spiele

Viele weitere fortgeschrittene Ressourcen finden Sie im Unity Best Practices Hub.