Spiel- und Systemprotokoll

Das Spielprotokoll zeigt alle Ausgaben der Engine, nativer Erweiterungen (native extensions) und deiner Spiellogik an. Mit den Befehlen print() und pprint() kannst du aus deinen Skripten und Lua-Modulen Informationen im Spielprotokoll anzeigen. Mit den Funktionen im Namensraum dmLog kannst du aus nativen Erweiterungen in das Spielprotokoll schreiben. Das Spielprotokoll kannst du im Editor, in einem Terminalfenster, mit plattformspezifischen Werkzeugen oder aus einer Protokolldatei lesen.

Systemprotokolle werden vom Betriebssystem erzeugt und können zusätzliche Informationen liefern, die dir helfen, ein Problem einzugrenzen. Die Systemprotokolle können Stacktraces zu Abstürzen und Warnungen bei knappem Arbeitsspeicher enthalten.

Das Spielprotokoll im Editor lesen

Wenn du dein Spiel lokal aus dem Editor oder über eine Verbindung zur mobilen Entwicklungs-App ausführst, werden alle Ausgaben im Konsolenbereich des Editors angezeigt:

Das Spielprotokoll im Terminal lesen

Wenn du ein Defold-Spiel aus dem Terminal startest, wird das Protokoll direkt im Terminalfenster angezeigt. Unter Windows und Linux gibst du den Namen der ausführbaren Datei im Terminal ein, um das Spiel zu starten. Unter macOS musst du die Engine aus der .app-Datei heraus starten:

$ > ./mygame.app/Contents/MacOS/mygame

Spiel- und Systemprotokolle mit plattformspezifischen Werkzeugen lesen

HTML5

Du kannst Protokolle mit den Entwicklerwerkzeugen lesen, die die meisten Browser bereitstellen.

• Chrome - Menu > More Tools > Developer Tools
• Firefox - Tools > Web Developer > Web Console
• Edge
• Safari - Develop > Show JavaScript Console

Android

Mit dem Werkzeug Android Debug Bridge (ADB) kannst du das Spiel- und Systemprotokoll anzeigen.

Das Kommandozeilenwerkzeug adb ist ein einfach zu bedienendes und vielseitiges Programm, mit dem du mit Android-Geräten interagieren kannst. Du kannst adb als Teil der Android SDK Platform-Tools für Mac, Linux oder Windows herunterladen und installieren.

Lade die Android SDK Platform-Tools hier herunter: https://developer.android.com/studio/releases/platform-tools. Das Werkzeug adb findest du unter /platform-tools/. Alternativ kannst du plattformspezifische Pakete über die jeweiligen Paketmanager installieren.

Unter Ubuntu Linux:

$ sudo apt-get install android-tools-adb

Unter Fedora 18/19:

$ sudo yum install android-tools

Unter macOS (Homebrew)

$ brew cask install android-platform-tools

Du kannst überprüfen, ob adb funktioniert, indem du dein Android-Gerät per USB mit deinem Computer verbindest und den folgenden Befehl ausführst:

$ adb devices
List of devices attached
31002535c90ef000    device

Wenn dein Gerät nicht angezeigt wird, prüfe, ob du USB debugging auf dem Android-Gerät aktiviert hast. Öffne auf dem Gerät Settings und suche nach Developer options (oder Development).

Verbinde nach der Installation und Einrichtung dein Gerät per USB, öffne ein Terminal und führe Folgendes aus:

$ cd <path_to_android_sdk>/platform-tools/
$ adb logcat

Das Gerät gibt dann sämtliche Ausgaben einschließlich der Ausgaben des Spiels im aktuellen Terminal aus.

Wenn du nur die Ausgaben der Defold-Anwendung sehen möchtest, verwende diesen Befehl:

$ cd <path_to_android_sdk>/platform-tools/
$ adb logcat -s defold
--------- beginning of /dev/log/system
--------- beginning of /dev/log/main
I/defold  ( 6210): INFO:ENGINE: Defold Engine 1.2.50 (8d1b912)
I/defold  ( 6210): INFO:ENGINE: Loading data from:
I/defold  ( 6210): INFO:ENGINE: Initialized sound device 'default'
I/defold  ( 6210):
D/defold  ( 6210): DEBUG:SCRIPT: Hello there, log!
...

iOS

Unter iOS hast du mehrere Möglichkeiten, Spiel- und Systemprotokolle zu lesen:

1. Du kannst das Werkzeug Console verwenden, um das Spiel- und Systemprotokoll zu lesen.
2. Du kannst den LLDB-Debugger mit einem Spiel verbinden, das auf einem Gerät läuft. Um ein Spiel zu debuggen, muss es mit einem „Apple Developer Provisioning Profile“ signiert sein, das das Gerät einschließt, auf dem du debuggen möchtest. Erstelle im Editor ein Bundle des Spiels und gib das Bereitstellungsprofil im Dialogfeld für die Bundle-Erstellung an (die Bundle-Erstellung für iOS ist nur unter macOS verfügbar).

Um das Spiel zu starten und den Debugger damit zu verbinden, benötigst du ein Werkzeug namens ios-deploy. Installiere und debugge dein Spiel, indem du Folgendes in einem Terminal ausführst:

$ ios-deploy --debug --bundle <path_to_game.app> # NOTE: not the .ipa file

Dadurch wird die App auf deinem Gerät installiert und gestartet, und ein LLDB-Debugger wird automatisch mit ihr verbunden. Wenn du LLDB noch nicht kennst, lies Erste Schritte mit LLDB.

Das Spielprotokoll aus der Protokolldatei lesen

Mit der Projekteinstellung „Write Log File“ in game.project steuerst du die Dateiprotokollierung:

• „Never“: Keine Protokolldatei schreiben.
• „Debug“: Nur für Debug-Builds eine Protokolldatei schreiben.
• „Always“: Sowohl für Debug- als auch für Release-Builds eine Protokolldatei schreiben.

Wenn die Dateiprotokollierung aktiviert ist, werden alle Spielausgaben in eine Datei namens „log.txt“ auf dem Datenträger geschrieben. So extrahierst du die Datei, wenn du das Spiel auf einem Gerät ausführst:

iOS

Verbinde dein Gerät mit einem Computer, auf dem macOS und Xcode installiert sind.

Öffne Xcode und gehe zu Window ▸ Devices and Simulators.

Wähle dein Gerät in der Liste aus und wähle dann die entsprechende App in der Liste Installed Apps aus.

Klicke auf das Zahnradsymbol unter der Liste und wähle Download Container....

Sobald der Container extrahiert wurde, wird er im Finder angezeigt. Klicke mit der rechten Maustaste auf den Container und wähle Show Package Content. Suche die Datei „log.txt“, die sich in „AppData/Documents/“ befinden sollte.

Android(

Ob du die Datei „log.txt“ extrahieren kannst, hängt von der Betriebssystemversion und dem Hersteller ab. Hier findest du eine kurze und einfache Schritt-für-Schritt-Anleitung.