Exportieren

Übersicht

Jetzt, da Du ein fertiges Spiel hast, willst Du wahrscheinlich Deinen Erfolg mit anderen teilen. Es ist jedoch nicht praktisch, Deine Freunde zu bitten, Godot herunterzuladen, nur damit sie Dein Projekt öffnen können. Stattdessen kannst Du Dein Projekt exportieren und in ein „Paket“ konvertieren, das von jedem ausgeführt werden kann.

Wie Du Dein Spiel exportierst, hängt davon ab, auf welche Plattform Du Dich fokussierst. In dieser Anleitung erfährst Du, wie Du das Spiel "Dodge the Creeps" für unterschiedliche Plattformen exportieren kannst. Zunächst müssen wir jedoch einige Änderungen an der Funktionsweise des Spiels vornehmen.

Bemerkung

Wenn du „Dodge the Creeps“ noch nicht selbst erstellt hast, lies bitte Dein erstes Spiel, bevor du mit dieser Anleitung weitermachst.

Vorbereitung des Projekts

In "Dodge the Creeps" verwendeten wir Tastatursteuerungen, um den Charakter des Spielers zu bewegen. Dies ist in Ordnung, wenn Ihr Spiel auf einer PC-Plattform gespielt wird, aber auf einem Telefon oder Tablett müssen Sie die Touchscreen-Eingabe unterstützen. Da ein Klickereignis wie ein Touch-Ereignis behandelt werden kann, konvertieren wir das Spiel in einen Click-and-Move-Eingabestil.

Standardmäßig emuliert Godot Mauseingaben von Berührungseingaben. Das bedeutet, dass alles, was darauf programmiert ist durch einen Maus-Event ausgelöst zu werden, auch bei Berührungen passiert. Godot kann auch Berührungseingaben von Mauseingaben emulieren. Das werden wir auch brauchen, nachdem wir auf Berührungseingaben gewechselt sind, um unser Spiel weiter an unserem Computer zu spielen. Setze dazu in den "Projekt-Einstellung" unter Input Devices und Pointing Emulate Touch From Mouse auf "An".

../../_images/export_touchsettings.png

Zudem wollen wir sichergehen, dass das Spiel auf unterschiedlich großen Bildschirmen gleich dargestellt bzw. skaliert wird. Dazu gehen wir in die Projekteinstellungen unter Display und klicken auf Window. In den Stretch-Optionen angekommen, änderst du Mode zu "2D" und Aspect zu "keep".

Da wir schon in den Window Einstellungen sind, sollten wir auch unter Handheld die Orientation auf portrait stellen.

../../_images/export_handheld_stretchsettings.png

Als nächstes müssen wir das Skript Player.gd ändern, um die Eingabemethode zu ändern. Wir entfernen die wichtigsten Eingaben und bringen den Spieler dazu, sich auf ein "Ziel" zuzubewegen, das durch das Berühren (oder Klicken) des Ereignisses festgelegt wird.

Hier ist das vollständige Skript für den Spieler, mit Kommentaren, die aufzeigen, was wir geändert haben:

extends Area2D

signal hit

export var speed = 400
var screen_size
# Add this variable to hold the clicked position.
var target = Vector2()

func _ready():
    hide()
    screen_size = get_viewport_rect().size

func start(pos):
    position = pos
    # Initial target is the start position.
    target = pos
    show()
    $CollisionShape2D.disabled = false

# Change the target whenever a touch event happens.
func _input(event):
    if event is InputEventScreenTouch and event.pressed:
        target = event.position

func _process(delta):
    var velocity = Vector2()
    # Move towards the target and stop when close.
    if position.distance_to(target) > 10:
        velocity = target - position

# Remove keyboard controls.
#    if Input.is_action_pressed("ui_right"):
#       velocity.x += 1
#    if Input.is_action_pressed("ui_left"):
#        velocity.x -= 1
#    if Input.is_action_pressed("ui_down"):
#        velocity.y += 1
#    if Input.is_action_pressed("ui_up"):
#        velocity.y -= 1

    if velocity.length() > 0:
        velocity = velocity.normalized() * speed
        $AnimatedSprite.play()
    else:
        $AnimatedSprite.stop()

    position += velocity * delta
    # We still need to clamp the player's position here because on devices that don't
    # match your game's aspect ratio, Godot will try to maintain it as much as possible
    # by creating black borders, if necessary.
    # Without clamp(), the player would be able to move under those borders.
    position.x = clamp(position.x, 0, screen_size.x)
    position.y = clamp(position.y, 0, screen_size.y)

    if velocity.x != 0:
        $AnimatedSprite.animation = "walk"
        $AnimatedSprite.flip_v = false
        $AnimatedSprite.flip_h = velocity.x < 0
    elif velocity.y != 0:
        $AnimatedSprite.animation = "up"
        $AnimatedSprite.flip_v = velocity.y > 0

func _on_Player_body_entered( body ):
    hide()
    emit_signal("hit")
    $CollisionShape2D.set_deferred("disabled", true)
using Godot;
using System;

public class Player : Area2D
{
    [Signal]
    public delegate void Hit();

    [Export]
    public int Speed = 400;

    private Vector2 _screenSize;
    // Add this variable to hold the clicked position.
    private Vector2 _target;

    public override void _Ready()
    {
        Hide();
        _screenSize = GetViewport().Size;
    }

    public void Start(Vector2 pos)
    {
        Position = pos;
        // Initial target us the start position.
        _target = pos;
        Show();
        GetNode<CollisionShape2D>("CollisionShape2D").Disabled = false;
    }

    // Change the target whenever a touch event happens.
    public override void _Input(InputEvent @event)
    {
        if (@event is InputEventScreenTouch eventMouseButton && eventMouseButton.Pressed)
        {
            _target = (@event as InputEventScreenTouch).Position;
        }
    }

    public override void _Process(float delta)
    {
        var velocity = new Vector2();
        // Move towards the target and stop when close.
        if (Position.DistanceTo(_target) > 10)
        {
            velocity = _target - Position;
        }

        // Remove keyboard controls.
        //if (Input.IsActionPressed("ui_right"))
        //{
        //    velocity.x += 1;
        //}

        //if (Input.IsActionPressed("ui_left"))
        //{
        //    velocity.x -= 1;
        //}

        //if (Input.IsActionPressed("ui_down"))
        //{
        //    velocity.y += 1;
        //}

        //if (Input.IsActionPressed("ui_up"))
        //{
        //    velocity.y -= 1;
        //}

        var animatedSprite = GetNode<AnimatedSprite>("AnimatedSprite");

        if (velocity.Length() > 0)
        {
            velocity = velocity.Normalized() * Speed;
            animatedSprite.Play();
        }
        else
        {
            animatedSprite.Stop();
        }

        Position += velocity * delta;
        // We still need to clamp the player's position here because on devices that don't
        // match your game's aspect ratio, Godot will try to maintain it as much as possible
        // by creating black borders, if necessary.
        // Without clamp(), the player would be able to move under those borders.
        Position = new Vector2(
            x: Mathf.Clamp(Position.x, 0, _screenSize.x),
            y: Mathf.Clamp(Position.y, 0, _screenSize.y)
        );

        if (velocity.x != 0)
        {
            animatedSprite.Animation = "walk";
            animatedSprite.FlipV = false;
            animatedSprite.FlipH = velocity.x < 0;
        }
        else if(velocity.y != 0)
        {
            animatedSprite.Animation = "up";
            animatedSprite.FlipV = velocity.y > 0;
        }
    }
    public void OnPlayerBodyEntered(PhysicsBody2D body)
    {
        Hide(); // Player disappears after being hit.
        EmitSignal("Hit");
        GetNode<CollisionShape2D>("CollisionShape2D").SetDeferred("disabled", true);
    }
}

Die Hauptszene festlegen

Die Main-Szene ist die Szene in der dein Spiel starten wird. Durch einen Klick auf das Ordnersymbol unter Project -> Project Settings -> Application -> Run legst du Main Scene auf "Main.tscn" fest.

Exportvorlagen

Um zu exportieren, müssen Sie die Exportvorlagen von der Website http://godotengine.org/download. herunterladen. Diese Vorlagen sind optimierte Versionen der Engine, ohne dass der Editor für jede Plattform vorkompiliert wird. Sie können sie auch in Godot herunterladen, indem Sie auf Editor -> Manage Export Templates klicken:

../../_images/export_template_menu.png

In dem erscheinenden Fenster können Sie auf "Download" klicken, um die Vorlagenversion zu erhalten, die Ihrer Version von Godot entspricht.

../../_images/export_template_manager.png

Bemerkung

Wenn Sie Godot aktualisieren, müssen Sie Vorlagen herunterladen, die der neuen Version entsprechen, da sonst Ihre exportierten Projekte möglicherweise nicht ordnungsgemäß funktionieren.

Exportvoreinstellungen

Anschließend kannst Du die Exporteinstellungen konfigurieren, indem Du auf Projekt -> Exportieren klickst:

Erstelle eine neue Exportvoreinstellung, indem Du auf "Hinzufügen" klickst und eine Plattform auswählst. Du kannst mit verschiedenen Einstellungen beliebig viele Voreinstellungen vornehmen.

../../_images/export_presets_window.png

Am unteren Rand des Fensters befinden sich zwei Schaltflächen. "Exportiere PCK/ZIP" erstellt nur eine gepackte Version der Daten Deines Projekts. Dies beinhaltet keine ausführbare Datei, so dass das Projekt nicht allein ausgeführt werden kann.

Die zweite Schaltfläche "Projekt exportieren" erstellt eine vollständig ausführbare Version Deines Spiels, z.B. ‚.apk‘ für Android oder eine ‚.exe‘ für Windows.

Auf den Registerkarten "Ressourcen" und "Funktionen" können Sie festlegen, wie das Spiel für jede Plattform exportiert wird. Wir können diese Einstellungen erst einmal so lassen wie sie sind.

Exportieren nach Plattform

In diesem Abschnitt werden wir den Prozess für jede Plattform durchgehen, einschließlich zusätzlicher Software oder Anforderungen, die Du benötigst.

PC (Linux/MacOS/Windows)

Der Export von PC-Plattformen funktioniert auf allen drei unterstützten Betriebssystemen gleich. Öffne das Exportfenster und klicke auf „Hinzufügen...“, um die gewünschte(n) Voreinstellung(en) zu erstellen. Klicke dann auf "Projekt exportieren" und wähle einen Namen und einen Zielordner aus. Wähle einen Ort außerhalb Deines Projektordners.

Klicke auf "Speichern" und die Engine erstellt die Exportdateien.

Bemerkung

Wenn Du dein Projekt für MacOS exportierst, dann wird auf einem MacOS-Computer eine .dmg-Datei erzeugt, während unter Linux oder Windows eine` .zip`-Datei erzeugt wird. In beiden Fällen enthält die komprimierte Datei eine MacOS .app, die Du doppelklicken und ausführen kannst.

Bemerkung

Wenn unter Windows die exportierte ausführbare Datei ein anderes Symbol als das Standardsymbol haben soll, musst Du es manuell ändern. Siehe dazu: Anwendungssymbol für Windows ändern.

Android

Tipp

Mobile Geräte verfügen über eine Vielzahl von Funktionen. In den meisten Fällen funktionieren die Standardeinstellungen von Godot, aber die Entwicklung für mobile Geräte ist manchmal mehr Kunst als Wissenschaft, und Du musst möglicherweise etwas experimentieren und nach Hilfe suchen, um alles zum Laufen zu bringen.

Bevor Du Dein Projekt für Android exportieren kannst, musst Du folgende Software herunterladen:

Wenn Du Android Studio zum ersten Mal ausführst, klicke auf Konfigurieren -> SDK-Manager und installiere „Android SDK Platform Tools“. Dadurch wird das Befehlszeilentool ‚adb‘ installiert, durch das Godot mit Deinem Gerät kommuniziert.

Erstelle als Nächstes einen „Debug-Keystore“, indem Du den folgenden Befehl in der Befehlszeile Deines Systems ausführst:

keytool -keyalg RSA -genkeypair -alias androiddebugkey -keypass android -keystore debug.keystore -storepass android -dname "CN=Android Debug,O=Android,C=US" -validity 9999

Klicke in Godot auf Editor -> Editoreinstellungen und wähle den Abschnitt Export/Android aus. Hier musst Du die Pfade zu den Android SDK-Anwendungen auf Deinem System und den Speicherort des gerade erstellten Schlüsselspeichers festlegen.

../../_images/export_editor_android_settings.png

Jetzt ist alles für den Export fertig. Klicke auf Projekt -> Exportieren und füge eine Voreinstellung für Android hinzu (siehe oben). Wähle die Voreinstellungen für Android aus und gehe in den Options unter Screen und setze Orientation auf "Portrait".

Klicke auf die Schaltfläche „Projekt exportieren“, und Godot erstellt eine APK, die Du auf Dein Gerät herunterladen kannst. Verwende dazu Folgendes in der Befehlszeile:

adb install dodge.apk

Bemerkung

Möglicherweise muss sich Dein Gerät im Entwicklermodus befinden. Weitere Informationen findest Du in der Dokumentation Deines Geräts.

Wenn Dein System dies unterstützt, wird beim Anschließen eines kompatiblen Android-Geräts die Schaltfläche "One-click Deploy" im Bereich der Godot Playtest-Schaltfläche angezeigt:

../../_images/export_android_oneclick.png

Durch Klicken auf diese Schaltfläche wird die APK erstellt und in einem Schritt auf Dein Gerät kopiert.

iOS

Bemerkung

Um Dein Spiel für iOS zu erstellen, benötigst Du einen Computer mit MacOS auf dem Xcode installiert ist.

Vor dem Exportieren musst Du einige Einstellungen vornehmen, damit das Projekt erfolgreich exportiert werden kann. Zuerst benötigst Du die „App Store Team Id“, die Du findest, indem Du Dich bei Deinem Apple-Entwicklerkonto anmeldest und im Abschnitt "Mitgliedschaft" nachsiehst.

Außerdem musst Du App-Icons und Begrüßungsbildschirme bereitstellen, wie unten gezeigt:

../../_images/export_ios_settings.png

Klicke auf "Projekt exportieren" und wähle einen Zielordner aus.

Nachdem Du das Projekt erfolgreich exportierst hast, findest Du an Deinem ausgewählten Speicherort die folgenden Ordner und Dateien:

../../_images/export_xcode_project_folders.png

Du kannst das Projekt jetzt in Xcode öffnen und das Projekt für iOS erstellen. Die Xcode-Buildprozedur geht über den Rahmen dieser Anleitung hinaus. Weitere Informationen findest Du unter https://help.apple.com/xcode/mac/current/#/devc8c2a6be1 .

HTML5 (web)

Klicke in der HTML5-Voreinstellung auf „Projekt exportieren“. Wir müssen keine der Standardeinstellungen ändern.

Wenn der Export abgeschlossen ist, hast Du einen Ordner mit den folgenden Dateien:

../../_images/export_web_files.png

Wenn Du die `.html'-Datei in Deinem Browser öffnest, kannst Du das Spiel spielen. Du kannst die Datei jedoch nicht direkt öffnen. Sie muss von einem Webserver bereitgestellt werden. Wenn Du noch keinen Webserver auf Deinem Computer eingerichtet hast, kannst Du z.B. mit einer Suchmaschine Anleitungen für Dein Betriebssystem dazu finden.

Öffnen Sie die URL in Ihrem Browser, unter der Sie die HTML-Datei abgelegt haben. Möglicherweise müssen Sie einige Sekunden warten, bis das Spiel geladen ist, bevor der Startbildschirm erscheint.

../../_images/export_web_example.png

Das Konsolenfenster unter dem Spiel zeigt an, ob etwas schief geht. Du kannst es deaktivieren, indem Du beim Exportieren des Projekts "Exportieren mit Debuggen" deaktivierst.

../../_images/export_web_export_with_debug_disabled.png

Bemerkung

Obwohl WASM in allen großen Browsern unterstützt wird, ist es immer noch eine aufkommende Technologie. Es funktioniert möglicherweise nicht alles. Stelle sicher, dass dein Browser auf die neueste Version aktualisiert wurde und melde eventuelle Bugs im Godot Github Repository.