Exportation¶

Vue d'ensemble¶

Maintenant que votre jeu fonctionne, vous voulez surement le partager. Seulement, demander à ses amis de télécharger Godot pour ouvrir votre projet, ce n'est pas très pratique. À la place, vous pouvez exporter votre projet, en le convertissant en un "package" pouvant être exécuté par n'importe qui.

La façon dont vous exportez votre jeu dépend de la plateforme visée. Dans ce tutoriel, vous allez apprendre comment exporter le jeu Dodge the Creeps pour différentes plateformes. Pour cela, nous devons déjà faire plusieurs modification sur la manière dont fonctionne le jeu.

Note

Si vous n'avez pas encore créé Dodge the Creeps vous même, veuillez lire Votre premier jeu en 2D avant de continuer ce tutoriel.

Préparation du projet¶

Dans Dodge the Creeps, nous avons utilisé les touches du clavier pour déplacer le personnage du joueur. Cela convient bien si votre jeu est joué sur un ordinateur, mais sur un téléphone ou une tablette, vous devez gérer l'entrée de l'écran tactile. Parce qu'un événement de clic peut être traité de la même façon qu'un événement de toucher de l'écran tactile, nous allons convertir le jeu vers un style de commande clic-mouvement.

Par défaut, Godot émule l'entrée de la souris à partir de l'entrée tactile. Cela signifie que si quelque chose est codé pour se produire sur un événement de souris, un événement de l'entrée tactile va le déclencher aussi. Godot peut également émuler l'entrée tactile depuis l'entrée de la souris, ce dont nous aurons besoin pour être en mesure de continuer à jouer à notre jeu sur notre ordinateur après être passé à l'entrée tactile.

Dans Project > Project Settings, sous Input Devices > Poiting, activez Emulate Touch From Mouse.

Nous voulons également nous assurer que le jeu s'adapte de manière cohérente sur des écrans de différentes tailles, donc dans les paramètres du projet allez sur Display, puis cliquez sur Window. Dans les options Stretch, réglez Mode sur 2d et Aspect sur keep.

Puisque nous sommes déjà dans les paramètres Window, nous devrions également régler, sous Handheld, l'Orientation sur portrait.

../../_images/export_handheld_stretchsettings.png

Nous devons ensuite modifier le script Player.gd pour changer la méthode d'entrée. Nous allons supprimer les entrées de touches du clavier et faire avancer le joueur vers une "cible" définie par l'événement de toucher (ou de clic).

Voici le script complet pour le joueur, avec des commentaires détaillant ce que nous avons changé :

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

Mise en place de la scène principale¶

La scène principale est celle avec laquelle votre jeu va démarrer. Pour cet exemple Dodge the Creeps, dans Projet-> Project Settings -> Application -> Run, réglez Main Scene sur Main.tscn en cliquant sur l'icône de dossier puis en la sélectionnant.

Exporter des modèles¶

Pour exporter, vous devez télécharger les modèles d'exportation à partir du site http://godotengine.org/download. Ces modèles sont des versions optimisées du moteur sans l'éditeur, pré-compilées pour chaque plate-forme. Vous pouvez également les télécharger dans Godot en cliquant sur Éditeur -> Gérer les modèles d'exportation :

Note

Si vous avez téléchargé Godot depuis Steam, les modèles exportés sont déjà inclus. Par conséquent, vous n'avez pas besoin de les télécharger à l'aide de la boîte de dialogue ** Manage Export Templates**.

Dans la fenêtre qui apparaît, vous pouvez cliquer sur Télécharger pour obtenir la version du modèle qui correspond à votre version de Godot.

../../_images/export_template_manager.png

Note

Les modèles exportés sont liés à une version spécifique de Godot. Si vous mettez à niveau Godot, vous devez télécharger des modèles correspondant à la nouvelle version.

Réglages d'export par défaut¶

Ensuite, vous pouvez configurer les paramètres d'exportation en cliquant sur Projet -> Exporter.

Créez un nouveau préréglage d'exportation en cliquant sur Ajouter.... et en sélectionnant une plate-forme. Vous pouvez faire autant de préréglages que vous le souhaitez avec des paramètres différents.

Au bas de la fenêtre se trouvent deux boutons. Export PCK/ZIP ne crée qu'une version compressée des données de votre projet. Cela n'inclut pas d'exécutable, le projet ne peut pas donc pas être exécuté seul.

Le deuxième bouton, Export Project, crée une version exécutable complète de votre jeu, comme un .apk pour Android ou un .exe pour Windows.

Dans les onglets Ressources et Fonctionnalités, vous pouvez personnaliser la manière dont le jeu est exporté pour chaque plate-forme. Nous pouvons laisser ces réglages tels-quels pour l'instant.

Exporter par plateforme¶

Dans cette section, nous passerons en revue le processus pour chaque plate-forme, y compris tout logiciel ou pré-requis supplémentaire dont vous aurez besoin.

PC (Linux / macOS / Windows)¶

L'exportation vers les plates-formes PC fonctionne de la même manière sur les trois systèmes d'exploitation pris en charge. Ouvrez la fenêtre d'exportation et cliquez sur Ajouter... pour créer le(s) pré-réglage(s) que vous voulez faire. Cliquez ensuite sur Exporter le projet et choisissez un nom et un dossier de destination. Choisissez un emplacement à l'extérieur de votre dossier de projet.

Cliquez sur Enregistrer et le moteur compilera les fichiers d'exportation.

Note

Lors de l'exportation pour MacOS, si vous exportez sur un ordinateur MacOS, vous obtiendrez un fichier .dmg, alors que l'exportation sous Linux ou Windows produit un .zip. Dans les deux cas, le fichier compressé contient un fichier MacOS .app que vous pouvez double-cliquer et exécuter.

Note

Sous Windows, si vous voulez que votre exécutable exporté ait une icône différente de celle par défaut, vous devez la changer manuellement. Voir Changer l'icone de l'application pour windows.

Android¶

Astuce

Les appareils mobiles sont dotés d'une grande diversité de caractéristiques. Dans la plupart des cas, les paramètres par défaut de Godot fonctionneront, mais le développement mobile est parfois plus artistique que scientifique, et vous aurez peut-être besoin d'expérimenter et de chercher de l'aide pour que tout fonctionne.

Avant de pouvoir exporter votre projet pour Android, vous devez télécharger le logiciel suivant :

Téléchargez et installez le SDK Android à partir de http://developer.android.com/sdk/index.html
Ouvrez le JDK (la version 8 est nécessaire, les versions plus récentes ne fonctionneront pas) : https://adoptopenjdk.net/index.html

Lorsque vous lancez Android Studio pour la première fois, cliquez sur Configure -> SDK Manager et installez Android SDK Platform Tools. Ceci installe l'outil en ligne de commande adb que Godot utilise pour communiquer avec votre appareil.

Créez ensuite une keystore de débogage en exécutant la commande suivante sur la ligne de commande de votre système :

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

Cliquez sur Éditeur -> Paramètres de l'éditeur dans Godot et sélectionnez la section Export/Android. Ici, vous devez définir les chemins d'accès aux applications Android SDK sur votre système et l'emplacement du keystore que vous venez de créer.

../../_images/export_editor_android_settings.png

Maintenant, vous êtes prêt à exporter. Cliquez sur Projet -> Export et ajoutez un préréglage pour Android (voir ci-dessus). Sélectionnez le préréglage Android nouvellement ajouté.Sous Options allez à Screen et réglez Orientation sur Portrait. Si votre jeu est en mode paysage (c'est-à-dire que la largeur de la fenêtre en pixels est supérieure à sa hauteur), laissez cette option sur Landscape.

Cliquez sur le bouton Exporter le projet et Godot compilera un APK que vous pourrez télécharger sur votre appareil. Pour ce faire utilisez ceci sur la ligne de commande, utilisez ce qui suit :

adb install dodge.apk

Note

Il se peut que votre appareil nécessite d'être en mode développeur. Consultez la documentation de votre appareil pour plus de détails.

Si votre système le prend en charge, la connexion d'un appareil Android compatible fera apparaître un bouton Déploiement en un clic dans la zone des boutons de test de Godot :

../../_images/export_android_oneclick.png

Cliquez sur ce bouton pour construire l'APK et le copier sur votre appareil en une seule étape.

iOS¶

Note

Pour compiler votre jeu pour iOS, vous devez disposer d'un ordinateur fonctionnant sous macOS avec Xcode installé.

Avant d'exporter, il y a quelques paramètres que vous devez remplir pour que le projet puisse être exporté avec succès. Tout d'abord, l'App Store Team Id, que vous pouvez trouver en vous connectant à votre compte de développeur Apple et en consultant la section Membership.

Vous devez également fournir des icônes et des images pour l'écran d'accueil comme indiqué ci-dessous :

Cliquez sur Exporter le projet et sélectionnez un dossier de destination.

Une fois que vous avez exporté le projet avec succès, vous trouverez les dossiers et fichiers suivants qui ont été créés à l'emplacement que vous avez choisi :

../../_images/export_xcode_project_folders.png

Vous pouvez maintenant ouvrir le projet dans Xcode et compiler le projet pour iOS. La procédure de compilation Xcode dépasse le cadre de ce tutoriel. Voir https://help.apple.com/xcode/mac/current/#/devc8c2a6be1 pour plus d'informations.

HTML5 (web)¶

Cliquez sur Exporter le projet sur le pré-réglage HTML5. Nous n'avons pas besoin de modifier les paramètres par défaut.

Quand l'exportation s'achève, le dossier de sortie devrait ressembler à ceci :

L'affichage du fichier .html dans votre navigateur vous permet de jouer au jeu. Cependant, vous ne pouvez pas ouvrir le fichier directement. Il doit être servi par un serveur web. Si vous n'en avez pas sur votre ordinateur, vous pouvez rechercher en ligne pour trouver des suggestions spécifique à votre système d'exploitation.

Pointez votre navigateur à l'URL où vous avez placé le fichier HTML. Vous devrez peut-être attendre quelques instants pendant que le jeu se charge avant de voir l'écran titre.

La fenêtre de la console sous le jeu vous indique si quelque chose ne va pas. Vous pouvez la désactiver en désactivant Exporter avec débogage dans la boîte de dialogue du fichier final qui apparaît lorsque vous exportez le projet.

../../_images/export_web_export_with_debug_disabled.png

Note

Bien que WebAssembly soit supporté dans tous les principaux navigateurs, il s'agit encore d'une technologie émergente et vous pouvez trouver certaines choses qui ne fonctionnent pas. Assurez-vous d'avoir mis à jour votre navigateur à la version la plus récente, et signalez tout bogue que vous trouvez sur le Godot GitHub repository.