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 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 the "Project Settings" under Input Devices and Pointing, set Emulate Touch From Mouse to "On".

../../_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. In Project -> Project Settings -> Application -> Run, set Main Scene to "Main.tscn" by clicking the folder icon and selecting it.

Eksportowanie szablonów

In order to export, 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

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

Jeśli zaktualizujesz Godot, musisz pobrać szablony które zgadzają się z nową wersją, inaczej Twój eksportowany projekt może nie działać poprawnie.

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.

Exporting by platform

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

When exporting for macOS, if you export on a macOS computer, you'll end up with a .dmg file, while using Linux or Windows produces a .zip. In either case, the compressed file contains a macOS .app that you can double-click and run.

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.

Next, create a debug keystore by running the following command on your system's command line:

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

Now you're ready to export. Click on Project -> Export and add a preset for Android (see above). Select the Android Presets and under Options go to Screen and set Orientation to "Portrait".

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

In order to build your game for iOS, you must have a computer running macOS with Xcode installed.

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

Viewing the .html file in your browser lets you play the game. However, you can't open the file directly, it needs to be served by a web server. If you don't have one set up on your computer, you can search online to find suggestions for your specific OS.

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

While WASM is supported in all major browsers, it is still an emerging technology and you may find some things that don't work. Make sure you have updated your browser to the most recent version, and report any bugs you find at the Godot GitHub repository.