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, auf welche Plattform Sie sich fokussieren. In dieser Anleitung erfahren Sie, wie Sie das Spiel "Dodge the Creeps" für unterschiedliche Plattformen exportieren können. 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 weitermachen.

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, ändern Sie 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 Ihr Spiel starten wird. Durch einen Klick auf das Ordnersymbol unter Project -> Project Settings -> Application -> Run legen Sie 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 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 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 Ihres 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 Ihres 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 Sie benötigen.

PC (Linux/MacOS/Windows)

Der Export von PC-Plattformen funktioniert auf allen drei unterstützten Betriebssystemen gleich. Öffnen Sie das Exportfenster 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

Wenn Sie Ihr Projekt für MacOS exportieren, 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 Sie doppelklicken und ausführen können.

Bemerkung

Wenn unter Windows die exportierte ausführbare Datei ein anderes Symbol als das Standardsymbol haben soll, müssen Sie 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 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 eine Voreinstellung für Android hinzu (siehe oben). Wählen Sie die Voreinstellungen für Android aus und gehen in den Options unter Screen und setzen Orientation auf "Portrait".

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.

Wenn 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 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 öffnen, 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 z.B. mit einer Suchmaschine Anleitungen für Ihr 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. Sie können es deaktivieren, indem Sie beim Exportieren des Projekts "Exportieren mit Debuggen" deaktivieren.

../../_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. Stellen Sie sicher, dass Ihr Browser auf die neueste Version aktualisiert wurde und melden eventuelle Bugs im Godot Github Repository.