Eksportowanie

Przegląd

Teraz, gdy masz już pracującą grę, prawdopodobnie chcesz podzielić się swoim sukcesem z innymi. Jednak nie jest to praktyczne, aby poprosić przyjaciół, aby pobrali Godota tylko po to, aby mogli otworzyć swój projekt. Zamiast tego możesz wyeksportować swój projekt, konwertując go na "pakiet", który może być uruchomiony przez każdego.

Sposób eksportowania gry zależy od platformy, na którą planujesz wydać ją. W tym samouczku dowiesz się jak eksportować grę "Dodge the Creeps" na różne platformy. Najpierw jednak musimy dokonać pewnych zmian w sposobie działania gry.

Informacja

Jeśli jeszcze nie stworzyłeś "Dodge the Creeps", przeczytaj Twoja pierwsza gra zanim przejdziesz do tego samouczka.

Przygotowanie projektu

W "Dodge the Creeps" użyliśmy klawiszy sterujących do poruszania postacią gracza. Jest to w porządku, jeśli grasz na platformie PC, ale na telefonie lub tablecie musisz obsługiwać ekrany dotykowe. Ponieważ zdarzenie kliknięcia może być traktowane jak zdarzenie dotyku, przekonwertujemy grę do stylu kliknij i porusz.

By default, Godot emulates mouse input from touch input. That means that if anything is coded to happen on a mouse event, touch will trigger it as well. Godot can also emulate touch input from mouse clicks, which we will need to be able to keep playing our game on our computer after we switch to touch input.

In Project > Project Settings, under Input Devices > Pointing, enable Emulate Touch From Mouse.

../../_images/export_touchsettings.png

We also want to ensure that the game scales consistently on different-sized screens, so in the project settings go to Display, then click on Window. In the Stretch options, set Mode to 2d and Aspect to keep.

Since we are already in the Window settings, we should also set under Handheld the Orientation to portrait.

../../_images/export_handheld_stretchsettings.png

Następnie musimy zmodyfikować skrypt Player.gd aby zmienić metodę wprowadzania danych. Usuniemy przyciski wejściowe i sprawimy, że gracz przejdzie do "celu", który jest ustawiany przez dotknięcie (lub kliknięcie).

Oto pełny skrypt dla gracza, z komentarzami wskazującymi co się zmieniło:

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);
    }
}

Ustawianie głównej sceny

The main scene is the one that your game will start in. For this Dodge the Creeps example, in Project -> Project Settings -> Application -> Run, set Main Scene to Main.tscn by clicking the folder icon and selecting it.

Szablony do eksportu

To export the project, you need to download the export templates from the http://godotengine.org/download. These templates are optimized versions of the engine without the editor pre-compiled for each platform. You can also download them in Godot by clicking on Editor -> Manage Export Templates:

../../_images/export_template_menu.png

Informacja

If you've downloaded Godot from Steam, export templates are already included. Therefore, you don't need to download them using the Manage Export Templates dialog.

W oknie które się wyświetliło, możesz kliknąć Pobierz aby pobrać wersję szablonu który zgadza się z wersją Godot.

../../_images/export_template_manager.png

Informacja

Export templates are bound to a specific Godot version. If you upgrade Godot, you must download templates that match the new version.

Eksportowanie ustawień wstępnych

Next, you can configure the export settings by clicking on Project -> Export.

Create a new export preset by clicking Add... and selecting a platform. You can make as many presets as you like with different settings.

../../_images/export_presets_window.png

At the bottom of the window are two buttons. Export PCK/ZIP only creates a packed version of your project's data. This doesn't include an executable so the project can't be run on its own.

The second button, Export Project, creates a complete executable version of your game, such as an .apk for Android or an .exe for Windows.

In the Resources and Features tabs, you can customize how the game is exported for each platform. We can leave those settings alone for now.

Eksportowanie w zależności od platformy

W tym dziale przejdziemy przez proces dla każdej platformy, włącznie z dodatkowym oprogramowaniem lub wymaganiami każdej z nich, których będziesz potrzebował.

PC (Linux/MacOS/Windows)

Eksportowanie na PC działa tak samo w trzech obsługiwanych systemach operacyjnych. Otwórz okno eksportu i kliknij "Dodaj...". Następnie kliknij "Eksportuj projekt" i wybierz nazwę oraz folder docelowy. Wybierz lokalizację na zewnątrz folderu projektu.

Kliknij Zapisz, a silnik wyeksportuje projekt.

Informacja

Podczas eksportowania do systemu MacOS, jeśli eksportujesz na komputerze MacOS, otrzymasz plik .dmg, podczas gdy używanie Linuksa lub Windows powoduje utworzenie pliku .zip. W obu przypadkach skompresowany plik zawiera aplikację MacOS .app, którą można dwukrotnie kliknąć i uruchomić.

Informacja

W systemie Windows, jeśli chcesz, aby wyeksportowany plik wykonywalny miał inną ikonę niż domyślna, musisz ręcznie ją zmienić. Patrz: Changing application icon for Windows.

Android

Wskazówka

Urządzenia mobilne mają wiele różnych konfiguracji. W większości przypadków, ustawienia domyślne Godota będą działać, ale rozwój mobilny jest czasami bardziej sztuką niż nauką i być może będziesz musiał zrobić kilka eksperymentów i szukać pomocy, aby wszystko działało.

Zanim będziesz mógł wyeksportować swój projekt dla systemu Android, musisz pobrać następujące oprogramowanie:

Przy pierwszym uruchomieniu Android Studio kliknij Configure -> SDK Manager i zainstaluj "Android SDK Platform Tools". To zainstaluje narzędzie wiersza poleceń adb używane przez Godota do komunikowania się z urządzeniem.

Następnie utwórz debug keystore, uruchamiając poniższe polecenie w wierszu poleceń systemu:

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

Kliknij na Edytor -> Ustawienia edytora i wybierz sekcję Export/Android. Tutaj musisz ustawić ścieżki do aplikacji Android SDK w swoim systemie i lokalizację właśnie utworzonego keystore.

../../_images/export_editor_android_settings.png

Teraz jesteś gotowy do eksportu. Kliknij Projekt -> Eksportuj i dodaj predefiniowane ustawienia dla systemu Android (zobacz powyżej).

Kliknij przycisk Eksportuj projekt, a Godot zbuduje APK, który możesz pobrać na twoje urządzenie. Aby to zrobić w wierszu poleceń, użyj następujących opcji:

adb install dodge.apk

Informacja

Możliwe że urządzenie będzie potrzebowało włączonego trybu Opcje Programistyczne. Szczegółowe informacje można znaleźć w dokumentacji urządzenia.

If your system supports it, connecting a compatible Android device will cause a One-click Deploy button to appear in Godot's playtest button area:

../../_images/export_android_oneclick.png

Kliknięcie tego przycisku spowoduje utworzenie APK i skopiowanie go do urządzenia w jednym kliknięciem.

iOS

Informacja

Aby zbudować swoją grę dla iOS, musisz mieć komputer macOS z zainstalowanym Xcode.

Przed wyeksportowaniem są pewne ustawienia, które musisz wprowadzić, aby projekt został wyeksportowany pomyślnie. Najpierw "App Store Team Id", który możesz znaleźć logując się na swoje konto dewelopera Apple i przeglądając sekcję "Membership".

Należy również ustawić ikonę oraz ekran startowy, jak pokazano poniżej:

../../_images/export_ios_settings.png

Kliknij Eksportuj projekt i wybierz folder docelowy.

Po pomyślnym wyeksportowaniu projektu w wybranym miejscu zostaną utworzone następujące foldery i pliki:

../../_images/export_xcode_project_folders.png

Możesz teraz otworzyć projekt w Xcode i zbudować projekt dla iOS. Procedura tworzenia w Xcode jest poza zakresem tego samouczka. Więcej informacji można znaleźć na stronie https://help.apple.com/xcode/mac/current/#/devc8c2a6be1 .

HTML5 (web)

Kliknij "Eksportuj projekt" w HTML5. Nie musimy zmieniać żadnych ustawień domyślnych.

Po zakończeniu eksportu zostanie wyświetlony folder zawierający następujące pliki:

../../_images/export_web_files.png

Uruchomienie pliku .html w przeglądarce pozwala grać w grę. Plik nie może być jednak otwierany bezpośrednio, musi być obsługiwany przez serwer WWW. Jeśli nie masz jego konfiguracji na swoim komputerze, możesz skorzystać z Google, aby znaleźć sugestie dotyczące Twojego konkretnego systemu operacyjnego.

Wskaż przeglądarce na adres URL, pod którym umieściłeś plik html. Być może będziesz musiał poczekać kilka chwil podczas ładowania się gry, zanim zobaczysz ekran startowy.

../../_images/export_web_example.png

Okno konsoli pod grą poinformuje, kiedy coś pójdzie nie tak. Możesz go wyłączyć, ustawiając opcję "Eksportuj z Debugowaniem" na wyłączony przy eksportowaniu projektu.

../../_images/export_web_export_with_debug_disabled.png

Informacja

Obsługa WASM przez przeglądarkę nie jest zbyt rozpowszechniona. Firefox i Chrome obsługują go, ale nadal mogą znajdować się rzeczy, które nie działają. Upewnij się, że zaktualizowałeś swoją przeglądarkę do najnowszej wersji i zgłosiłeś wszelkie błędy na które się natknąłeś, które znajdziesz w repozytorium `Godot Github <https://github.com/godotengine/godot/issues>``_.