Exportieren

Übersicht

Jetzt, da Sie ein fertiges Spiel haben, wollen Sie wahrscheinlich Ihren Erfolg mit anderen teilen. Es ist jedoch nicht praktisch Ihre Freunde zu bitten Godot herunterzuladen, nur damit sie Ihr Projekt öffnen können. Stattdessen können Sie Ihr Projekt exportieren und in ein „Paket“ konvertieren, das von jedem ausgeführt werden kann.

Wie Sie Ihr Spiel exportieren hängt davon ab, welches die Zielplattformen sind. In dieser Anleitung erfahren Sie, wie das Spiel Dodge the Creeps für unterschiedliche Plattformen exportieren werden kann. Zunächst müssen wir jedoch einige Änderungen an der Funktionsweise des Spiels vornehmen.

Bemerkung

Wenn Sie Dodge the Creeps noch nicht selbst erstellt haben, lesen Sie bitte Das erste Spiel, bevor Sie mit dieser Anleitung fortfahren.

Vorbereitung des Projekts

In „Dodge the Creeps“ verwendeten wir eine Tastatursteuerung, um die Spielfigur zu bewegen. Dies ist in Ordnung wenn das Spiel auf einem Computer gespielt wird, aber auf einem Smartphone oder Tablett müssen Touchscreen-Eingaben unterstützt werden. Da ein Klickereignis wie ein Touch-Ereignis behandelt werden kann, konvertieren wir die Steuerung zu einen Click-and-Move-Eingabestil.

Standardmäßig emuliert Godot Touch-Eingaben als Mauseingaben. Alles, was darauf programmiert ist durch ein Maus-Event ausgelöst zu werden, wird also auch durch Touch-Eingaben ausgelöst. Godot kann auch Mauseingaben als Touch-Events behandeln. Das werden wir benötigen, um unser Spiel weiter an unserem Computer zu spielen, nachdem wir auf Touch-Eingaben gewechselt sind.

Setze dazu bei Projekt > Projekteinstellungen unter Input Devices > Pointing den Wert von Emulate Touch From Mouse auf "An".

../../_images/export_touchsettings.png

Zudem wollen wir sichergehen, dass das Spiel auf unterschiedlich großen Bildschirmen einheitlich skaliert wird. Dazu gehen wir in die Projekteinstellungen unter Display und klicken auf Window. In den Stretch-Optionen angekommen, ändern wir Mode zu 2d und Aspect zu keep.

Da wir schon in den Window-Einstellungen sind, sollten wir auch unter Handheld die Orientation zu portrait ändern.

../../_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 Hauptszene ist die Szene in der das Spiel starten wird. Für das Beispiel Dodge the Creeps ändern Sie in Projekt -> Projekteinstellungen -> Application -> Run den Wert von Main Scene auf Main.tscn, indem Sie auf das Ordnersymbol klicken und die Szene auswählen.

Exportvorlagen

Um das Projekt zu exportieren, müssen die Exportvorlagen von http://godotengine.org/download herunterladen werden. Diese Vorlagen sind optimierte Versionen ohne den vorkompilierten Editor der Engine für jede Plattform. Sie können auch in Godot selbst durch einen Klick auf Editor -> Manage Export Templates heruntergeladen werden:

../../_images/export_template_menu.png

Bemerkung

Wenn Sie Godot auf Steam heruntergeladen haben, sind die Exportvorlagen bereits enthalten. Deshalb müssen sie nicht im Manage Export Templates-Dialog heruntergeladen werden.

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

Die Exportvorlagen sind an eine spezifische Godot-Version gebunden. Wenn Sie auf eine neue Godot-Version aktualisieren, müssen Sie die entsprechenden Vorlagen herunterladen.

Exportvoreinstellungen

Anschließend können Sie die Exporteinstellungen konfigurieren, indem Sie auf Projekt -> Exportieren... klicken.

Erstellen Sie eine neue Exportvoreinstellung, indem Sie auf Hinzufügen... klicken und eine Plattform auswählen. Sie können beliebig viele verschiedene Voreinstellungen erstellen.

../../_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 Ihres Projekts. Dies beinhaltet keine ausführbare Datei, das Projekt kann nicht alleine ausgeführt werden.

Die zweite Schaltfläche Projekt exportieren erstellt eine vollständige, ausführbare Version Ihres Spiels, beispielsweise eine .apk für Android oder eine .exe für Windows.

Auf den Registerkarten Ressourcen und Funktionen kann festgelegt werden, 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 Sie benötigen.

PC (Linux/MacOS/Windows)

Der Export von PC-Plattformen funktioniert auf allen drei unterstützten Betriebssystemen gleich. Öffnen Sie das Exportieren-Fenster und klicken auf Hinzufügen..., um die gewünschte(n) Voreinstellung(en) zu erstellen. Klicken Sie dann auf Projekt exportieren und wählen einen Namen und einen Zielordner aus. Wählen Sie einen Ort außerhalb Ihres Projektordners.

Klicken Sie auf Speichern und die Engine erstellt die Exportdateien.

Bemerkung

Bei einem Export für MacOs wird auf einem MacOS-Computer eine .dmg-Datei erzeugt, unter Linux oder Windows eine .zip-Datei. In beiden Fällen enthält die komprimierte Datei eine MacOS .app, welche sich durch einen Doppelklick ausführen lässt.

Bemerkung

Wenn unter Windows die exportierte ausführbare Datei ein anderes Symbol als das Standardsymbol haben soll, muss es manuell geändert werden. Siehe 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 Sie müssen möglicherweise etwas experimentieren und nach Hilfe suchen, um alles zum Laufen zu bringen.

Bevor Sie Ihr Projekt für Android exportieren können, müssen Sie folgende Software herunterladen:

Wenn Sie Android Studio zum ersten Mal ausführen, klicken Sie auf Konfigurieren -> SDK-Manager und installieren Android SDK Platform Tools. Dadurch wird das Befehlszeilentool adb installiert, durch das Godot mit Ihrem Gerät kommuniziert.

Erstellen Sie als Nächstes einen „Debug-Keystore“, indem Sie den folgenden Befehl in der Befehlszeile Ihres Systems ausführen:

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

Klicken Sie in Godot auf Editor -> Editoreinstellungen und wählen den Abschnitt Export/Android aus. Hier müssen Sie die Pfade zu den Android SDK-Anwendungen auf Ihrem System und den Speicherort des gerade erstellten Schlüsselspeichers festlegen.

../../_images/export_editor_android_settings.png

Jetzt ist alles für den Export fertig. Klicken Sie auf Projekt -> Exportieren... und fügen Sie eine Voreinstellung für Android hinzu (siehe oben). Wählen Sie die erzeugte Voreinstellungen für Android aus und gehen Sie in Optionen zu Screen, Orientation auf Portrait zu setzen. Ist das zu exportierende Spiel im Landschaftsmodus (d.h. die Breite des Fensters ist größer als seine Höhe), lassen Sie den Wert auf Landscape.

Klicken Sie auf die Schaltfläche Projekt exportieren und Godot erstellt eine APK, die Sie auf Ihr Gerät herunterladen können. Verwenden Sie dazu Folgendes in der Befehlszeile:

adb install dodge.apk

Bemerkung

Möglicherweise muss sich Ihr Gerät im Entwicklermodus befinden. Weitere Informationen finden Sie in der Dokumentation Ihres Geräts.

Falls Ihr 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 Ihr Gerät kopiert.

iOS

Bemerkung

Um Ihr Spiel für iOS zu erstellen, benötigen Sie einen Computer mit MacOS auf dem Xcode installiert ist.

Vor dem Exportieren müssen Sie einige Einstellungen vornehmen, damit das Projekt erfolgreich exportiert werden kann. Zuerst benötigen Sie die App Store Team Id, die Sie finden, indem Sie sich bei Ihrem Apple-Entwicklerkonto anmelden und im Abschnitt Mitgliedschaft nachsehen.

Außerdem müssen Sie App-Icons und Begrüßungsbildschirme bereitstellen, wie unten gezeigt:

../../_images/export_ios_settings.png

Klicken Sie auf Projekt exportieren und wählen Sie einen Zielordner aus.

Nachdem Sie das Projekt erfolgreich exportiert haben, finden Sie an Ihrem ausgewählten Speicherort die folgenden Ordner und Dateien:

../../_images/export_xcode_project_folders.png

Sie können 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 finden Sie unter https://help.apple.com/xcode/mac/current/#/devc8c2a6be1.

HTML5 (web)

Klicken Sie in der HTML5-Voreinstellung auf Projekt exportieren. Wir müssen keine der Standardeinstellungen ändern.

Wenn der Export abgeschlossen ist, haben Sie einen Ordner mit den folgenden Dateien:

../../_images/export_web_files.png

Wenn Sie die .html-Datei in Ihrem Browser betrachten, können Sie das Spiel spielen. Sie können die Datei jedoch nicht direkt öffnen. Sie muss von einem Webserver bereitgestellt werden. Wenn Sie noch keinen Webserver auf Ihrem Computer eingerichtet haben, können Sie durch eine Onlinesuche Vorschläge für Ihr Betriebssystem finden.

Öffnen Sie in Ihrem Browser die URL, 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. Sie können es deaktivieren, indem Sie im Datei-Dialog, welcher beim Exportieren erscheint, Exportieren mit Debuggen deaktivieren.

../../_images/export_web_export_with_debug_disabled.png

Bemerkung

Obwohl WebAssembly von allen bekannten Browsern unterstützt wird, ist es immer noch eine aufkommende Technologie. Es funktioniert möglicherweise nicht alles. Stellen Sie sicher, dass Ihr Browser auf die neueste Version aktualisiert wurde und melden Sie eventuelle Bugs im Godot Github Repository.