Premiers pas avec Unity et Google Play Jeux pour PC

1. Introduction

Dernière mise à jour : 18/10/2022

Comment préparer votre jeu pour Google Play Jeux sur PC ?

Google Play Jeux vous permet de porter facilement votre jeu mobile sur les PC Windows. Vous pouvez ainsi accroître l'engagement de vos joueurs et élargir votre audience sans avoir à repenser l'architecture de votre jeu ni à modifier votre modèle économique. Il reste quelques modifications à apporter pour offrir la meilleure expérience possible à vos nouveaux joueurs sur PC.

Points abordés

Cet atelier de programmation couvre les éléments de base de la checklist des exigences pour vous aider à lancer votre jeu et à le préparer pour Google Play Jeux sur PC. Les intégrations plus approfondies, telles que la connexion à Play Jeux et l'API Play Integrity, ne sont pas abordées.

• Compiler pour l'architecture x86 à partir d'Unity
• Découvrez comment tester et déployer votre jeu sur l'émulateur Google Play Jeux.
• Découvrez comment modifier votre interface utilisateur pour qu'elle s'affiche correctement sur un PC.
• Découvrez comment détecter si vous exécutez votre jeu dans l'émulateur Google Play Jeux et comment l'adapter en conséquence.

Prérequis

• Installation d'Unity 2020 LTS (cet atelier de programmation a été créé avec la version 2020.3.30f1).
• L'émulateur Google Play Jeux.

2. Configuration

Ouvrir ou créer un projet

1. Créez un projet à l'aide du microjeu de plate-forme 2D ou ouvrez votre propre projet.

2. Dans le projet, sélectionnez File > Build Settings (Fichier > Paramètres de compilation) et vérifiez que vous êtes configuré pour compiler pour Android.

3. Préparer l'émulateur Google Play Jeux

Commencez par télécharger l'émulateur.

Une fois l'installation terminée, un bureau Android devrait s'afficher dans une fenêtre :

Remarque : L'émulateur apparaît sous le nom Émulateur pour développeur Google Play Jeux dans la liste de vos applications.

Il s'agit d'un environnement Android hautes performances complet adapté au développement de jeux. Il devrait s'afficher dans Android Debug Bridge (adb) en tant qu'appareil sur localhost :

❯ adb devices
List of devices attached
localhost:6520  device

Vous devez disposer d'une version récente d'adb pour détecter l'émulateur. La version fournie avec Android Studio fonctionne, mais il est possible que ce ne soit pas le cas de celle fournie avec Unity. Une version compatible est fournie avec l'émulateur. Vous la trouverez sous C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Pour une expérience de développement optimale, vous pouvez installer Android Studio et l'utiliser pour gérer votre SDK Android.

Si l'émulateur se déconnecte d'adb, reconnectez-le à partir de la ligne de commande comme suit :

adb connect localhost:6520

4. Configurer Unity pour compiler et déployer directement sur l'émulateur (facultatif)

Il est possible que la version d'adb fournie avec Unity ne soit pas compatible avec l'émulateur. Pour vous en assurer, sélectionnez File > Build Settings (Fichier > Paramètres de compilation), puis vérifiez si l'appareil est listé dans la boîte de dialogue Run Device (Exécuter sur l'appareil).

Attention : N'oubliez pas d'utiliser adb connect localhost:6520 avec la version d'adb fournie avec Unity si vous avez déjà exécuté adb avant le test. Au moment de la rédaction de cet article, aucune des versions de Unity testées n'est fournie avec un adb compatible.

Selon votre projet, votre processus de compilation et votre niveau de confort, vous pouvez choisir de configurer Unity pour qu'il se déploie directement sur l'émulateur Google Play Jeux, ou de compiler un fichier APK et de le déployer manuellement avec adb install. Le déploiement manuel nécessite le moins de modifications, mais peut ralentir votre cycle d'itération.

Déployez directement sur l'émulateur en deux étapes :

1. Configurez Unity pour qu'il utilise un autre SDK Unity, idéalement celui installé par Android Studio.
2. Mettez à jour la version des outils de compilation pour contourner un bug dans Unity.

Étant donné que la version du SDK Android fournie avec Unity ne détectera probablement pas l'émulateur, vous devez utiliser Android Studio pour installer un SDK plus récent.

1. Ouvrez Android Studio, puis sélectionnez Edit > Preferences > External Tools (Modifier > Préférences > Outils externes).
2. Décochez Android SDK Tools Installed with Unity, puis indiquez le chemin d'installation d'Android Studio (généralement AppData/Local/Android/sdk). Ne modifiez pas l'option Android NDK.

Lorsque vous actualisez les appareils connectés, Google HPE device (localhost:6520) devrait s'afficher dans la fenêtre de compilation :

Remarque : Si l'émulateur ne s'affiche pas, vous devrez peut-être exécuter adb connect localhost:6520. En effet, l'adb intégré à Unity est prioritaire jusqu'à ce que vous le modifiiez et que vous vous reconnectiez manuellement à la nouvelle instance adb.

Selon l'état de ce bug et votre version d'Unity, vous devrez peut-être également modifier la version de vos outils de compilation. Pour ce faire, vérifiez que vous générez un mainTemplate.gradle et un launcherTemplate.gradle.

3. Ouvrez la fenêtre Project Settings (Paramètres du projet), puis Player Settings (Paramètres du lecteur) et recherchez la section Publishing Settings.
4. Faites défiler la page jusqu'aux options Build (Compilation), puis cochez "Custom Main Gradle Template" (Modèle Gradle principal personnalisé) et "Custom Launcher Gradle Template" (Modèle Gradle du lanceur personnalisé). Les deux fichiers Gradle seront générés sous Assets\Plugins\Android\.

Remarque : Les projets utilisant les bibliothèques EDM4U et androidx, comme Firebase, nécessitent également de générer un Custom Gradle Properties Template pour résoudre correctement les dépendances. Si vous n'avez jamais utilisé de modèle Gradle personnalisé, vous pouvez également vérifier ce paramètre.

1. Remplacez toutes les instances de la chaîne **BUILDTOOLS** par 30.0.0. Dans les deux fichiers, la section de code doit maintenant se lire comme suit :

android {
    compileSdkVersion **APIVERSION**
    buildToolsVersion '30.0.0'

5. Déployer sur un Chromebook (facultatif)

Vous pouvez commencer à développer des jeux pour Google Play Jeux sans avoir accès à l'émulateur Google Play Jeux en utilisant un appareil ChromeOS. Tout comme Google Play Jeux sur PC, les Chromebooks sont équipés de claviers et de souris, disposent de grands écrans et sont disponibles dans des configurations x86. Nous allons utiliser le plug-in Unity Android Logcat avec le Chromebook.

1. Ouvrez le gestionnaire de packages et recherchez Android Logcat sous Unity Registry.

Vous devez également configurer votre Chromebook pour le développement Android. Commencez par activer Linux.

2. Sélectionnez Paramètres > Développeur > Linux.

Ensuite, activez le débogage ADB.

3. Sélectionnez Paramètres > Développeurs > Environnement de développement Linux > Développer des applications Android > Activer le débogage ADB.

Vous devez également obtenir l'adresse IP de votre Chromebook. Le moyen le plus simple de le faire est de

4. Cliquez sur l'icône Informations sur le réseau pour obtenir l'adresse IP de votre Chromebook.

5. Sélectionnez Window > Analysis > Android Logcat (Fenêtre > Analyse > Android Logcat) pour ouvrir la fenêtre Android Logcat.

6. Ouvrez la liste des appareils. Elle peut indiquer No Device si aucun appareil n'est actuellement connecté.

7. Cliquez sur Autres options de connexion, puis saisissez l'adresse IP de votre Chromebook.

8. Cliquez sur Se connecter. Une fenêtre Success (Réussite) devrait s'afficher :

Votre Chromebook apparaît désormais dans la liste des appareils d'exécution de Unity (vous devrez peut-être d'abord actualiser l'écran) :

Vous pouvez désormais déployer des jeux sur votre Chromebook et commencer à les tester et à les développer sur du matériel semblable à celui d'un PC.

6. Déployer un build de test

Google Play Jeux exige que vous déployiez une version x86 de votre jeu, ce qui lui permet d'atteindre ses benchmarks de performances sur les ordinateurs de bureau. Toutes les variantes LTS d'Unity peuvent générer des versions Android compatibles x86 et x86-64 (libellées "ChromeOS"), et Unity 2018 et les versions antérieures peuvent générer des versions x86. Pour déverrouiller ces architectures, vous devez d'abord passer au backend de script IL2CPP, ce que vous faites probablement déjà en production pour la prise en charge d'arm64.

1. Sélectionnez File > Build Settings (Fichier > Paramètres de compilation) pour ouvrir la fenêtre "Build Settings" (Paramètres de compilation), puis cliquez sur Player Settings (Paramètres du lecteur).

2. Accédez à la section Autres paramètres et définissez votre Scripting Backend sur IL2CPP.

Vous devez également activer la compatibilité avec x86 ou x86-64. Pour être disponible sur la plate-forme Google Play Jeux, vous n'avez besoin que de la compatibilité x86, bien que nous recommandions x86-64.

Remarque : Chaque architecture supplémentaire que vous ajoutez augmente la durée de compilation. Même si vous pouvez regrouper toutes vos cibles ARM et x86 dans un même bundle, vous pouvez choisir de n'utiliser que x86 ou x86-64 lors du développement de fonctionnalités.

La version de la bibliothèque Frame Pacing fournie avec Unity est également incompatible avec Google Play Jeux et entraîne le plantage de votre jeu au lancement.

3. Pour désactiver le frame pacing dans la fenêtre Player Settings (Paramètres du lecteur), ouvrez la section Resolution and Presentation (Résolution et présentation), puis décochez Optimized Frame Pacing (Frame pacing optimisé).

Vous êtes maintenant prêt à créer !

1. Ouvrez de nouveau la fenêtre Build Settings (Paramètres de compilation), puis cliquez sur Build And Run (Compiler et exécuter). Votre jeu s'affiche dans la fenêtre de l'émulateur.

Si vous ne parvenez pas à déployer votre jeu, vérifiez si "Google HPE device (localhost:6520)" s'affiche dans votre liste "Run Device" (Exécuter sur l'appareil). Si elle est manquante, assurez-vous que HPE_Dev est en cours d'exécution et que vous pouvez voir l'écran d'accueil Android. S'il n'apparaît toujours pas dans la liste des appareils, exécutez adb connect localhost:6520 avec le adb.exe exact que vous utilisez. Si vous utilisez le plug-in Android Logcat Unity, sélectionnez Tools > Open Terminal (Outils > Ouvrir le terminal) pour ouvrir un terminal dans le répertoire utilisé par adb.exe.

Ouvrir le terminal" style="width: 624.00px" src="img/9101ce3c95fb1aa2.png" srcset="img/9101ce3c95fb1aa2_36.png 36w, img/9101ce3c95fb1aa2_48.png 48w, img/9101ce3c95fb1aa2_72.png 72w, img/9101ce3c95fb1aa2_96.png 96w, img/9101ce3c95fb1aa2_480.png 480w, img/9101ce3c95fb1aa2_720.png 720w, img/9101ce3c95fb1aa2_856.png 856w, img/9101ce3c95fb1aa2_960.png 960w, img/9101ce3c95fb1aa2_1440.png 1440w, img/9101ce3c95fb1aa2_1920.png 1920w, img/9101ce3c95fb1aa2_2880.png 2880w" sizes="(max-width: 840px) 100vw, 856px">

7. Adapter votre jeu pour PC

Dans la mesure du possible, essayez d'apporter des modifications à votre jeu en fonction de métriques indépendantes de la plate-forme ou de la présence de certaines fonctionnalités. Par exemple, un joueur sur Android peut brancher une souris et un clavier ou un écran. En modifiant votre schéma de contrôle ou les éléments de votre HUD en fonction de la configuration de votre appareil, vous pouvez exploiter Google Play Jeux sur PC sur toutes vos plates-formes compatibles.

Si vous souhaitez modifier la logique en fonction de la plate-forme sur laquelle se trouve le joueur (Google Play Jeux ou ChromeOS), ce script vous aide à la détecter en recherchant la fonctionnalité système HPE_EXPERIENCE :

using UnityEngine;

public class GoogleDeviceUtilities
{
#if UNITY_ANDROID && !UNITY_EDITOR
    private static AndroidJavaObject PackageManager
    {
        get
        {
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            return currentActivity.Call<AndroidJavaObject>("getPackageManager");
        }
    }

    public static bool IsChromeOS => PackageManager.Call<bool>("hasSystemFeature", "org.chromium.arc");

    public static bool IsGooglePlayGames =>
        PackageManager.Call<bool>("hasSystemFeature", "com.google.android.play.feature.HPE_EXPERIENCE");

    public static bool HasKeyboard
    {
        get
        {
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            var resources = currentActivity.Call<AndroidJavaObject>("getResources");
            var configuration = resources.Call<AndroidJavaObject>("getConfiguration");
            var keyboard = configuration.Get<int>("keyboard");
            return keyboard == 2; // Configuration.KEYBOARD_QWERTY
        }
    }
#else
    public static bool IsChromeOS => false;
    public static bool IsGooglePlayGames => false;
    public static bool HasKeyboard => true;
#endif
}

Les PC ont un écran plus grand que les téléphones Android classiques. Dans la mesure du possible, nous vous recommandons de ne pas faire occuper plus de 20 % de l'écran par votre HUD. Étant donné que de nombreux jeux mobiles utilisent "Scale With Screen Size" (Adapter à la taille de l'écran), passer à "Constant Physical Size" (Taille physique constante) ou "Constant Pixel Size" (Taille en pixels constante) peut être un bon point de départ pour atteindre cet objectif.

Vous pouvez également définir de manière dynamique les paramètres de qualité à l'aide de la commande QualitySettings.SetQualityLevel au moment de l'exécution si vous détectez que vous exécutez le jeu dans Google Play Jeux. L'émulateur Google Play Jeux utilise ANGLE pour émettre des commandes DirectX ou Vulkan natives à partir d'OpenGL Unity. Vous pouvez donc probablement obtenir une fidélité graphique supérieure à celle disponible sur vos versions de jeux mobiles.

8. Traitement des entrées

Les jeux disponibles sur Google Play Jeux doivent être conçus pour une saisie à la souris et au clavier. Vous devrez planifier la façon dont vous interagissez avec votre jeu à l'aide d'une souris et d'un clavier. Prenez donc le temps d'acquérir le fichier unitypackage du SDK Input. Si aucun téléchargement ne s'affiche sur cette page, assurez-vous d'être connecté avec un compte appartenant au groupe play-mp-libs.

À des fins de test, de nombreux jeux créent des commandes de base pour la souris et le clavier afin de pouvoir être développés dans l'éditeur. Si possible, vous pouvez activer ces options lorsque vous exécutez l'application sur un appareil ChromeOS ou dans l'émulateur Google Play Jeux.

Remarque : Si vous utilisez actuellement #if UNITY_EDITOR pour détecter si vous exécutez dans l'éditeur, remplacez-le par la vérification de l'exécution if (Application.isEditor) afin de vérifier également GoogleDeviceUtilities.IsGooglePlayGames ou GoogleDeviceUtilities.HasKeyboard.

Par défaut, Google Play Jeux et ChromeOS convertissent les entrées de la souris en simulation tactile. Si vous utilisez Input.GetTouch et Input.touchCount, votre jeu continue de fonctionner comme prévu. Si vous vous appuyez sur des entrées multitouch, comme des commandes à deux pouces ou le pincement pour zoomer, vous devez mapper l'action sur des frappes de touches. Vous devez également mapper les actions du jeu sur des frappes de touches, par exemple appuyer sur i pour ouvrir votre inventaire, sur Échap pour fermer les boîtes de dialogue et sur Entrée pour envoyer des messages dans le jeu.

Le microjeu de plate-forme 2D utilise les flèches pour se déplacer et la barre d'espace pour sauter. Si vous utilisez votre propre jeu, assurez-vous d'avoir vos liaisons de touches préférées pour l'étape suivante.

9. Intégration du SDK Input

Maintenant que vous avez configuré les commandes de la souris et du clavier, vous devez ajouter la compatibilité avec le SDK Input . Cela aide les joueurs à découvrir vos entrées PC grâce à un pop-up pratique :

1. Après avoir importé le SDK dans votre projet, créez un fichier nommé InputMappingProviderBehaviour.cs et ajoutez-y le contenu suivant :

using System.Collections.Generic;
using Google.Play.InputMapping;
using UnityEngine;
using Input = Google.Play.InputMapping.Input;

public class InputMappingProviderBehaviour : MonoBehaviour
{
    private void Start()
    {
        Input.GetInputMappingClient().RegisterInputMappingProvider(new MyInputMappingProvider());
    }

    private class MyInputMappingProvider : InputMappingProvider
    {
        public InputMap OnProvideInputMap()
        {
            return new InputMap
            {
                InputGroups = new List<InputGroup> { },
                MouseSettings = new MouseSettings
                {
                    InvertMouseMovement = false,
                    AllowMouseSensitivityAdjustment = false
                }
            };
        }
    }

    private enum ActionIds
    {
    }
}

2. Remplissez maintenant ActionIds avec la liste des actions que vous utilisez dans votre jeu. Pour le microjeu de plate-forme 2D, les actions sont "Gauche", "Droite" et "Sauter" :

private enum ActionIds
{
    Left,
    Right,
    Jump
}

3. Dans OnProvideInputMap, créez un InputAction pour chaque action. Pour cela, vous avez besoin du nom de l'action, de l'entrée, puis des boutons de la souris ou des codes de touche qui y seront associés. Pour l'exemple de jeu :

var leftAction = new InputAction
{
    ActionLabel = "Walk Left",
    UniqueId = (int)ActionIds.Left,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_DPAD_LEFT
        }
    }
};

var rightAction = new InputAction
{
    ActionLabel = "Walk Right",
    UniqueId = (int)ActionIds.Right,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_DPAD_RIGHT
        }
    }
};

var jumpAction = new InputAction
{
    ActionLabel = "Jump",
    UniqueId = (int)ActionIds.Jump,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_SPACE
        }
    }
};

4. Ensuite, regroupez ces actions d'entrée.

Pour le microjeu, nous n'avons qu'un seul groupe, mais vous pouvez en créer autant que nécessaire pour aider vos joueurs à trouver les actions dont ils ont besoin. Ajoutez ceci à OnProvideInputMap :

var movementInputGroup = new InputGroup
{
    GroupLabel = "Movement",
    InputActions = new List<InputAction>
    {
        leftAction, rightAction, jumpAction
    }
};

5. Ajoutez tous les groupes d'entrée que vous avez créés à la carte d'entrée. Modifiez l'instruction return dans OnProvideInputMap pour qu'elle se lise comme suit :

return new InputMap
{
    InputGroups = new List<InputGroup> { movementInputGroup },
    MouseSettings = new MouseSettings
    {
        InvertMouseMovement = false,
        AllowMouseSensitivityAdjustment = false
    }
};

6. Enfin, ajoutez le script que vous avez créé à votre jeu :

7. Lorsque vous déployez à nouveau votre jeu, appuyez sur Shift+Tab pour ouvrir la superposition dans le jeu.

8. Cliquez sur Contrôles pour afficher les contrôles que vous avez configurés.

10. Supprimer les vues Web intégrées

Pour offrir une expérience optimale à vos joueurs, vous devez supprimer les vues Web intégrées. Il est courant d'utiliser des bibliothèques WebView intégrées pour afficher des éléments tels que vos règles de confidentialité ou vos conditions d'utilisation. Bien que ces intents fonctionnent dans Google Play Jeux, ils s'affichent dans un navigateur mobile intégré plutôt que dans le navigateur de bureau préféré du joueur, ce qui peut prêter à confusion pour les joueurs sur PC. Par conséquent, dans Unity, si vous utilisez des extensions pour afficher un navigateur intégré, revenez à Application.OpenURL(url).

11. Autorisations et fonctionnalités

Un certain nombre de fonctionnalités et d'autorisations Android ne sont pas compatibles avec Google Play Jeux. En règle générale, votre compilation PC ne doit jamais afficher de boîte de dialogue d'autorisation. Maintenant que votre build est prêt, il est conseillé de procéder à une nouvelle installation typique et de noter toutes les boîtes de dialogue que vous voyez pour les ajouter à votre liste de tâches à effectuer avant d'envoyer votre jeu.

Certains jeux Unity demandent des autorisations à l'aide de l'API Android.Permission. Vous devez les inclure dans des vérifications if (GoogleDeviceUtilities.IsGooglePlayGames) et passer directement à votre logique d'échec, le cas échéant.

12. Optimisations pour ordinateur

Google Play Jeux présente quelques différences par rapport à un téléphone Android classique. Vous devrez peut-être configurer votre jeu en conséquence.

Passez à DXT pour la compression de texture. Les formats de texture Android courants tels que ETC sont décodés en mémoire au moment de l'exécution s'ils ne peuvent pas être transmis directement au GPU d'un lecteur. ASTC offre la meilleure compatibilité avec les ordinateurs de bureau, mais vous devez utiliser un outil de profilage GPU pour ordinateur de bureau afin de vérifier le comportement attendu de votre jeu.

Puisque vous exécutez désormais votre jeu sur un GPU d'ordinateur, vous pouvez également augmenter la qualité des graphismes. Vous pouvez le modifier directement dans les paramètres de votre projet, sous Qualité.

13. Félicitations

Vous avez tout ce qu'il faut pour commencer à travailler sur votre jeu pour Google Play Jeux. Vous pouvez commencer à tester votre jeu et à l'améliorer. N'oubliez pas que même si vous pouvez conserver la même base de code, vous devrez adapter votre jeu pour qu'il ressemble à un jeu PC natif.

Et ensuite ?

Il reste encore du travail à faire pour publier un jeu sur Google Play Jeux :

• Pour obtenir les dernières informations, consultez le guide de démarrage rapide.
• Passez à la version 2 de la connexion aux services de jeux Play pour connecter automatiquement un joueur au lancement et répondre aux exigences de continuité.
• Implémentez l'API Play Integrity pour que votre expérience sur PC soit aussi sécurisée que sur mobile.

Enfin, une grande partie du travail que vous avez effectué jusqu'à présent pour prendre en charge Google Play Jeux vous aide également à distribuer votre jeu sur ChromeOS. Vous devriez envisager de prendre en charge cette plate-forme en plus du PC.