Skripting in Unity Grundkurs

Das einfache Debugging

Testen Sie unsere 1985 Kurse

10 Tage kostenlos!

Jetzt testen Alle Abonnements anzeigen
Früher oder später kommt es auf jeden Programmierer zu: Debugging. Fehler schleichen sich immer wieder ein; wie Sie diese auf einfache Art und Weise erkennen können, verrät dieses Video.
07:04

Transkript

Eine Sache können wir beim Programmieren leider nie verhindern, auch wenn wir uns noch so anstrengen, und das ist Machen von Fehlern. Unsere Skripts können sehr schnell Fehler enthalten, dabei kann das ein Fehler sein, wie "Ich hab mal ein Semikolon vergessen" oder eine Klammer, aber es kann auch ein Fehler in der Berechnung an sich sein. Das heißt, das sogenannte Debugging ist ein sehr wichtiges Element beim Programmieren. Debugging, das kommt von dem Begriff Bug, und Bug beschreibt einen Fehler im Programmcode, das etwas nicht so läuft, wie es laufen soll. Das Debugging ist also der Prozess, diesen Fehler wieder rauszubügeln, dass das Ganze wieder funktioniert. Ich habe dafür hier ein kleines Skript vorbereitet, DebugExample, und ein leeres Game Objekt, das ich jetzt einfach mal Debugger genannt habe. Dabei darf man bitte nicht denken, dass das ein Automatismus wäre, der unsere Fehler automatisch ausbügelt, das wäre schön, wenn es so etwas gäbe, aber leider müssen wir unsere Fehler auch noch selber beheben. Das Skript bietet uns die Möglichkeit, zwei Werte festzusetzen, x und y, wir bekommen keine Fehlermeldung, das heißt, an sich von der Syntax her, haben wir kein Zeichen vergessen, keine Klammer fehlt, oder kein Semikolon, die Berechnung kann also ausgeführt werden. Und wir kucken mal, was die Berechnung macht, okay, irgendwie scheint sie mit diesen beiden Werten zu jonglieren, und hier kommt 0,965 irgendwas heraus. Das kann ich auch ändern - und was ich hier eintrage, wird sofort in die Berechnung mit einbezogen. Wir kucken jetzt auch mal in das Skript rein, und schauen, was es denn macht. Hier haben wir unsere beiden Werte festgelegt, und hier unten wird etwas mit ihnen gemacht. Dabei ist diese Berechnung nur ein Beispiel, ich habe versucht, das hier so einfach wie möglich zu halten, aber trotzdem zu erklären, hier passieren gewisse Berechnungen, die außerdem noch aufeinander aufbauen. Rein von dem Geschriebenen, wie gesagt, ist alles super, der Compiler beziehungsweise das Programm sagt, kann ich berechnen, und hier bauen Berechnungen sogar aufeinander auf. Hier wird x und y genommen, und mit a weiter gerechnet. Dann wird ein Wert b erstellt, der wiederum mit a und x und y etwas tut, und dann wird sogar noch ein Wert c hergestellt, der wiederum mit b und a etwas tut. Das heißt also, in Berechnung #1 berechnen wir irgendeinen Wert, Berechnung #2 basiert darauf, und in Berechnung #3 basiert eine dritte Berechnung sogar auf den beiden davor. Und jetzt stellen wir uns vor, wir würden hier Werte herausbekommen, die uns überhaupt nicht gefallen. Selbst wenn wir hier an den Werten herumspielen, dann kann es ja sein, dass wir gewisse Werte erwarten, hier zum Beispiel, warum ist das denn so ein krummer Wert? Wir hätten hier vielleicht eine Zwei, eine glatte Zwei erwartet. Warum passiert das, warum ist das so? Und wir wissen nicht genau, was passiert. Denn die Berechnung ist im Moment einfach noch zu komplex, wir wissen nicht genau, wie unser Rechner denn jetzt auf diese krummen Werte kommt. Und hier setzt ein sehr einfaches Debugging ein, was uns in die Lage versetzt, einfach mal in diese Berechnung reinzukucken, einfach mal nachvollziehen zu können, was denn da überhaupt passiert. Und das ist relativ simpel, wie wir das machen können, nämlich zum Beispiel einfach indem wir uns per Debug.Log die Zwischenergebnisse ausgeben können. Da können wir dann zum Beispiel kombinieren, Wir schreiben in Strings, also in eine Zeichenkette mit Anführungszeichen hinein: ("B ist: ) das ist ja Klartext, da können wir alles reinschreiben, was wir wollen, und wir verknüpfen es mit einem Plus. Wir sagen also, liebes Debut.Log, - also liebe Anweisung, die du etwas in eine Konsole reinschreibst - schreibe erst Klartext: ("B ist: ), das ist ein Hinweis für uns, dass wir jetzt das Ergebnis von b anzeigen. Und dann schreiben wir einfach B dahin, denn das sagt dem Debug.Log, gib mir den derzeitigen Wert von B doch mal bitte aus. Hier unten sehen wir die Endausgabe, heraus kommt am Ende C. Aber uns fehlen die Zwischenschritte. Und genauso wie für B machen wir das jetzt auch für A, und sagen dann ("A ist: ) - natürlich müssen wir das B dann hier gegen das A austauschen, und durch die einfache Ausgabe der jeweiligen Zwischenschritte können wir dann in Unity, in der Konsole, Dinge nachvollziehen. Hier sehen wir, das erste Zwischenergebnis ist also hier irgendetwas mit 182, B ist dann 180, das könnte uns bis hierhin noch gefallen. Und dann kommt am Ende plötzlich was ganz anderes dabei rum, Moment, da stimmt doch irgendwas nicht, und dann wissen wir, aha, bis hierhin ist alles okay, bis hierhin war auch noch alles gut, aber hier bei unserer Endausgabe, ab da stimmt es nicht. Im Umkehrschluss können wir also sagen, unser Fehler ist nicht hier. Das kann alles so stehen bleiben, und das ist für uns schon ein Riesenfortschritt, denn wenn wir uns jetzt vorstellen, das ist nicht so eine einfach Berechnung mit ein paar Zeilen Code, sondern schon etwas Komplexeres, können wir das einen Riesenabschnitt einfach rausschmeißen, und den schon mal als richtig deklarieren, und haben unsere Fehlersuche extrem eingeschränkt, und es uns damit um einiges leichter gemacht. Und wenn wir jetzt hier ganz einfach sagen, na klar, diese Berechnung hier, die ist doch völliger Quatsch, was haben wir uns denn dabei gedacht, dann sagen wir einfach, A + B das ist ja viel richtiger, jetzt natürlich nur als Beispiel, und wir kontrollieren nochmal, und die resultierende Zahl ist eine viel plausiblere, in diesem Fall gefällt sie uns viel besser, keine krumme Kommazahl, 180 plus 180, ungefähr 360, alles gut. Und wenn wir dann auch noch mit den richtigen Werten arbeiten, dann kommen auch glatte Zahlen dabei rum. Und so funktioniert das einfache Debugging. Am einfachen Beispiel erklärt, es passieren Berechnungen, die an sich und vom Programmcode her korrekt sind, aber bei denen wir uns vielleicht vertan haben, wir haben vielleicht Werte vertauscht, falsche Berechnungen angefügt, multipliziert statt dividiert, oder andere Fehler gemacht, die nun mal vorkommen. Und indem wir uns Zwischenschritte ausgeben, in die Konsole schreiben, können wir separieren, bis wohin stimmt es noch, und ab wann gefällt es uns nicht mehr.

Skripting in Unity Grundkurs

Greifen Sie mithilfe von C#-Skripts dynamisch in Ihr Unity-Projekt ein. Auch Programmier-Neulinge lernen Schritt für Schritt den Einstieg ins Skripting.

4 Std. 50 min (40 Videos)
Derzeit sind keine Feedbacks vorhanden...
 

Anleitung für Unity 5-Nutzer:

  • Schritt 1: Projekt in Unity 5 öffnen und die Meldung bestätigen, dass das Projekt ein Upgrade bekommt.
  • Schritt 2: Wenn die Meldung kommt, dass die API upgedatet werden muss, diese auch bestätigen

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!