Premiers pas avec Unity et Google Play Jeux pour PC

1. Présentation

Logo Google Play Jeux

Dernière mise à jour:25/04/2022

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

Avec Google Play Jeux, accédez facilement à votre jeu mobile sur votre PC Windows. Cela vous permet de développer l'engagement des joueurs et votre audience sans avoir à repenser votre jeu ni à repenser votre modèle économique. Vous devez encore apporter quelques modifications afin de proposer une expérience optimale à vos nouveaux lecteurs PC.

Points abordés

Cet atelier de programmation aborde les bases de la checklist des conditions requises pour vous permettre de lancer votre jeu et vous aider à préparer votre propre jeu Unity pour Google Play Jeux sur PC. Les intégrations plus approfondies, telles que Play Jeux et l'API Play Integrity, ne sont pas couvertes.

  • Créer une architecture x86 d'Unity
  • Tester et déployer sur l'émulateur Google Play Jeux
  • Modifier votre interface utilisateur pour qu'elle s'affiche correctement sur PC
  • Comment détecter si vous utilisez l'émulateur Google Play Jeux et adapter votre jeu en conséquence

Prérequis

2. Configuration

Ouvrir ou créer un projet

  1. Créez un projet à l'aide du microjeu 2D Platformer ou ouvrez votre propre projet.

Écran "Unity project" (Nouveau projet) d'Unity : le "2D Platformer Microgame" est sélectionné comme modèle à créer.

  1. Dans le projet, sélectionnez File -> Build Settings (Fichier -> Paramètres de compilation), puis vérifiez que vous avez bien configuré la compilation pour Android.

Capture d'écran de la fenêtre "Paramètres de compilation" d'Unity ; la plate-forme "Android" est active.

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

Commencez par télécharger l'émulateur à partir de cette page. Si vous ne voyez pas de lien de téléchargement, vérifiez que vous êtes connecté avec un compte qui a été ajouté au groupe play-mp-emu. Les membres de ce groupe reçoivent une notification lorsque les mises à jour de l'émulateur sont disponibles. Assurez-vous donc que vous pouvez recevoir des e-mails de play-mp-emu@googlegroups.com.

Une fois l'application installée, un bureau Android doit s'afficher dans une fenêtre:

Capture d'écran de la fenêtre de l'émulateur Google Play Jeux : l'écran d'accueil Android est visible.

Cet environnement Android hautes performances est adapté aux développeurs 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 de adb pour détecter l'émulateur. La version intégrée d'Android Studio fonctionne, mais pas ab. comme Unity. Une version compatible est fournie avec l'émulateur. Vous pouvez la trouver sur C:\Program Files\Google\HPE_Dev\emulator. Afin de proposer une expérience de développement optimale, nous vous conseillons d'installer Android Studio et de 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 créer un déploiement et le déployer directement dans l'émulateur (facultatif)

La version d'Adb expédiée avec Unity peut ne pas être compatible avec l'émulateur. Pour ce faire, sélectionnez File -> Build Settings (Fichier -> Paramètres du build), puis vérifiez si la boîte de dialogue Run Device (Exécuter l'appareil) figure dans la liste.

Dans la fenêtre "Build Settings" (Exécuter l'appareil), l'option "Run Device" (Exécuter l'appareil) est sélectionnée. Les seuls éléments visibles sont "Default device" (Appareil par défaut) et "All compatible devices" (Tous les appareils compatibles).

Selon votre projet, le processus de compilation et le niveau de confort, vous pouvez choisir de configurer Unity pour le déployer directement dans l'émulateur Google Play Jeux, ou de créer un 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.

Suivez ces deux étapes pour déployer directement l'émulateur:

  1. Configurez Unity de sorte 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.

Comme la version du SDK Android envoyée avec Unity ne détectera probablement pas l'émulateur, vous devez installer Android Studio sur une version plus récente.

  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 et indiquez le chemin d'accès à l'installation d'Android Studio (généralement AppData/Local/Android/sdk). Laissez l'option Android NDK intacte.

Capture d'écran d' "External Tools" (Outils externes) dans la fenêtre "Preferences" (Préférences)

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

Capture d'écran de la fenêtre "Build Settings" (Paramètres de compilation) : la commande "Run Device" (Exécuter l'appareil) "Google HPE" est visible.

En fonction de l'état de ce bug et de 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 des mainTemplate.gradle et des launcherTemplate.gradle.

  1. Ouvrez la fenêtre Project Settings (Paramètres du projet) dans Player Settings (Paramètres du lecteur), puis localisez la section Publishing Settings.
  2. Faites défiler la page jusqu'aux options Build (Créer), puis cochez "Custom Main Gradle Template" (Modèle Gradle principal personnalisé) et "Custom Launch Gradle Template" (Modèle Gradle personnalisé) pour générer les deux fichiers Gradle sous Assets\Plugins\Android\.

Capture d'écran de la section "Player" dans la fenêtre "Paramètres du projet".  Les cases "Modèle Gradle principal personnalisé" et "Modèle Gradle personnalisé" sont toutes cochées.

  1. Remplacez toute occurrence de la chaîne **BUILDTOOLS** par 30.0.0. Dans les deux fichiers, la section du code doit se présenter 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 accéder à l'émulateur Google Play Jeux à l'aide d'un appareil Chrome OS. Tout comme Google Play Jeux sur PC, les Chromebooks sont dotés de claviers et de souris, ainsi que d'un grand écran. Ils sont disponibles avec les configurations x86. Nous allons utiliser le plug-in Unity Android Logcat avec le Chromebook.

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

Fenêtre du gestionnaire de packages avec l'option "Android Logcat" sélectionnée.

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

  1. Sélectionnez Paramètres -> Développeur -> Linux.

Image animée montrant comment activer la compatibilité avec Linux.  Le développeur est sélectionné dans la fenêtre "Paramètres". puis sur "Activer"
à partir de "Environnement de développement Linux".

Activez ensuite le débogage ADB.

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

Le débogage ADB est activé à partir du menu pour les développeurs.

Vous devrez également obtenir l'adresse IP de votre Chromebook. Pour ce faire, le moyen le plus simple consiste à

  1. Cliquez sur l'icône Infos réseau pour obtenir l'adresse IP de votre Chromebook.

Capture d'écran de la fenêtre "Réseau" ouverte sur un Chromebook.

Cliquez sur le bouton d'informations sur le réseau pour afficher l'adresse IP.

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

Fenêtre>Analyse ouverte dans Unity avec l'option "Android Logcat" sélectionnée.

  1. Ouvrez la liste des appareils. No Device peut être lu si rien n'est actuellement connecté.

Fenêtre Android Logcat affichée, menu déroulant de l'appareil sélectionné.

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

Fenêtre "Autres connexions" ouverte. Une adresse IP est saisie.

  1. Cliquez sur Connecter. Une fenêtre Success (Réussite) doit s'afficher:

Une boîte de dialogue indiquant "Réussite" est ouverte.

Le Chromebook apparaît désormais dans la liste "Run Device" (Appareil à exécuter) d'Unity (vous devrez peut-être actualiser l'écran au préalable):

La fenêtre "Build Settings" de Unity est ouverte. L'appareil Chrome OS s'affiche dans le menu déroulant "Exécuter l'appareil".

Vous pouvez désormais déployer des jeux sur votre Chromebook et commencer à tester et développer vos applications sur du matériel de type PC.

6. Déployer un build de test

Pour utiliser Google Play Jeux, vous devez déployer une version x86 de votre jeu, ce qui s'inscrit dans le cadre de la procédure permettant d'atteindre ses performances de référence sur les ordinateurs. Toutes les variantes LTS d'Unity peuvent générer des builds Android x86 et x86-64 (libellés "Chrome OS") et les versions 2018 et antérieures d'Unity peuvent générer des builds x86. Pour déverrouiller ces architectures, vous devez d'abord passer au backend de script IL2CPP, que vous utilisez probablement déjà en production pour la compatibilité 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).

Capture d'écran de la fenêtre "Build Settings" (Paramètres de compilation) axée sur le bouton "Player Settings" (Paramètres du lecteur).

  1. Accédez à la section Autres paramètres, puis définissez Scripting Backend sur IL2CPP.

Capture d'écran de la section "Autres paramètres" de "Paramètres du lecteur"

Vous devez également activer la compatibilité avec x86 ou x86-64. Pour utiliser la plate-forme Google Play Jeux, il vous suffit de prendre en charge x86. Cependant, nous recommandons l'utilisation de x86-64.

Capture d'écran de la section "Configuration" des paramètres du lecteur "Backend de script" définie sur "IL2CPP" pour les architectures cibles, avec "x86 (Chrome OS)" et "x86-64 (Chrome OS)" encadrés.

La version des lots Unity de Frame Race est également incompatible avec Google Play Jeux et entraîne le plantage de votre jeu au lancement.

  1. Pour désactiver le rythme de la fenêtre dans la fenêtre Paramètres du lecteur, ouvrez la section Résolution et présentation, puis décochez l'option Fréquence d'images optimisée.

Capture d'écran "Résolution et présentation" avec l'option "Rythme du cadre optimisé" décochée

Vous êtes maintenant prêt à créer des applications.

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

Capture d'écran de l'émulateur Google Play Jeux avec "2D Platformer Microgame" en cours d'exécution

Si vous ne parvenez pas à déployer votre jeu, vérifiez si "Appareil Google HPE (localhost:6520)" apparaît dans la liste "Exécuter l'appareil". S'il est absent, vérifiez que HPE_Dev est en cours d'exécution et que l'écran d'accueil Android s'affiche. S'il n'apparaît toujours pas dans la liste des appareils, exécutez adb connect localhost:6520 avec l'adb.exe exact que vous utilisez. Si vous utilisez lePlug-in Android Logcat Unity, sélectionnezOutils -> Ouvrir le terminal pour ouvrir un terminal dans le répertoire avec le mêmeadb.exe Unity utilise.

Capture d'écran de la fenêtre "Android Logcat" dans Unity, avec "Tools > Open Terminal" (Outils > Terminal ouvert) encadré

7. Adaptez votre jeu pour PC

Si possible, essayez d'apporter des modifications à votre jeu en fonction de métriques propres à la plate-forme ou de la présence de certaines fonctionnalités. Par exemple, un joueur sous Android peut connecter une souris et un clavier ou brancher un écran. Par conséquent, si vous modifiez le schéma de contrôle ou les éléments HUD en fonction de la configuration de votre appareil, vous pouvez utiliser Google Play Jeux sur PC pour toutes les plates-formes compatibles.

S'il est judicieux de modifier la logique selon que le lecteur se trouve dans Google Play Jeux ou dans Chrome OS, ce script vous permet de le 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 ordinateurs sont dotés d'un écran plus grand que le téléphone Android classique. Si possible, nous vous recommandons d'occuper jusqu'à 20% de votre écran. Étant donné que de nombreux jeux mobiles utilisent la fonctionnalité "Échelle avec taille d'écran", vous pouvez commencer par passer à "Taille physique constante" ou à "Taille de pixel constante" pour atteindre cet objectif.

Capture d&#39;écran de l&#39;outil d&#39;inspection &quot;Canvas Scaler&quot; avec la liste &quot;Modes de mise à l&#39;échelle de l&#39;interface utilisateur&quot; affichée : &quot;Taille de pixels constante&quot;, &quot;Échelle avec taille d&#39;écran&quot; et &quot;Taille physique constante&quot;. L&#39;option &quot;Taille de pixel constante&quot; est sélectionnée.

Vous pouvez également définir dynamiquement les paramètres de qualité à l'aide de la commande QualitySettings.SetQualityLevel au moment de l'exécution, si vous détectez que vous utilisez Google Play Jeux. L'émulateur Google Play Jeux utilise ANGLE pour émettre des commandes DirectX ou Vulkan à partir des émissions OpenGL Unity. Vous aurez donc probablement une meilleure fidélité graphique que celle disponible dans vos builds de jeux mobiles.

8. Traitement des entrées

La livraison des jeux sur Google Play Jeux doit être basée sur la souris et le clavier. Vous devez planifier comment interagir avec votre jeu à l'aide de la souris et du clavier. Prenez donc le temps d'acquérir le package d'un SDK d'entrée. Si aucun téléchargement ne s'affiche sur cette page, vérifiez que vous êtes connecté avec un compte appartenant au groupe play-mp-libs.

À des fins de test, de nombreux jeux permettent de développer des commandes de base pour la souris et le clavier dans l'éditeur. Dans la mesure du possible, il peut être utile de les activer lorsque vous utilisez un appareil Chrome OS ou l'émulateur Google Play Jeux.

Par défaut, Google Play Jeux et Chrome OS transforment la saisie en souris en une simulation. Si vous utilisez Input.GetTouch et Input.touchCount, votre jeu continue de fonctionner comme prévu. Si vous utilisez une entrée multitouch, comme les commandes double pouce ou le zoom par pincement, vous devez associer l'action aux touches. Vous devez également mapper les actions dans le jeu sur les touches utilisées, par exemple en appuyant 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 microgameer 2D utilise les flèches pour vous déplacer et vous permet de sauter dans l'espace. Si vous utilisez votre propre jeu, assurez-vous d'avoir vos liaisons de clés préférées pour l'étape suivante.

9. Intégration du SDK d'entrée

Maintenant que les commandes de la souris et du clavier sont configurées, vous devez ajouter la compatibilité avec le SDK Input . Les lecteurs pourront ainsi découvrir votre saisie PC avec une fenêtre 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
    {
    }
}
  1. Remplissez maintenant ActionIds avec la liste des actions que vous utilisez dans votre jeu. Pour le microgameer 2D Platformer, les actions sont "Left", "Right" et "Jump" :
private enum ActionIds
{
    Left,
    Right,
    Jump
}
  1. Dans OnProvideInputMap, créez un InputAction pour chaque action. Pour cela, vous devez indiquer le nom de l'action, l'entrée, puis les boutons de la souris ou les codes clés qui lui 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
        }
    }
};
  1. Placez-les ensuite en groupes.

Pour le micro-jeu, nous n'avons qu'un seul groupe, mais vous pouvez en créer autant que vous le souhaitez 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
    }
};
  1. Ajoutez tous les groupes d'entrée que vous avez créés à la carte d'entrée. Modifiez l'instruction return dans OnProvideInputMap pour obtenir le code suivant:
return new InputMap
{
    InputGroups = new List<InputGroup> { movementInputGroup },
    MouseSettings = new MouseSettings
    {
        InvertMouseMovement = false,
        AllowMouseSensitivityAdjustment = false
    }
};
  1. Enfin, ajoutez le script que vous avez créé à votre jeu:

Capture d&#39;écran d&#39;un nœud nommé &quot;InputSdk&quot; avec le comportement &quot;Input Mapping Provider Behaviour&quot; (Comportement du fournisseur de mappage d&#39;entrée)

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

Capture d&#39;écran de la superposition &quot;Options de jeu&quot; dans l&#39;émulateur Google Play Jeux

  1. Cliquez sur Commandes pour afficher celles que vous avez configurées.

Capture d&#39;écran de la superposition &quot;Commandes&quot; dans l&#39;émulateur Google Play Jeux

10. Supprimer les annonces et les vues Web intégrées

Nous n'aborderons pas toute la logique à mettre à jour, mais vous devez traiter deux points immédiatement afin de réussir l'approbation de l'application et offrir une expérience optimale aux joueurs.

Tout d'abord, il est courant d'utiliser les vues Web intégrées pour afficher des éléments comme vos règles de confidentialité ou vos conditions d'utilisation. Bien que ces fonctionnalités fonctionnent dans Google Play Jeux, elles s'affichent dans un navigateur mobile intégré plutôt que dans le navigateur préféré du lecteur. Elles peuvent donc entraîner une certaine confusion pour les lecteurs PC. Par conséquent, dans Unity, si vous utilisez des extensions pour afficher un navigateur intégré, revenez à Application.OpenURL(url).

Ensuite, les annonces ne sont pas autorisées dans Google Play Jeux, mais vous pouvez laisser vos SDK publicitaires pour vos lecteurs mobiles et Chrome OS. Utilisez GoogleDeviceUtilities.IsGooglePlayGames pour déterminer si vous devez inclure des annonces dans le jeu. Les autres API de paiement, comme Google Pay, fonctionneront comme prévu.

11. Autorisations et fonctionnalités

Certaines fonctionnalités et autorisations Android ne sont pas compatibles avec Google Play Jeux. En règle générale, la version de votre PC ne doit jamais afficher de boîte de dialogue d'autorisations. Maintenant que votre build est prêt, nous vous recommandons de passer par une nouvelle installation classique et de consigner toutes les boîtes de dialogue que vous souhaitez ajouter à votre liste de tâches pour la mise en ligne de votre jeu.

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

12. Optimisations des ordinateurs

Google Play Jeux présente quelques différences par rapport à un téléphone Android classique. Nous vous conseillons de configurer votre jeu en conséquence.

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

Fenêtre &quot;Paramètres de compilation&quot; d&#39;Unity, avec &quot;Texture Compression&quot; développée &quot;DXT (Tegra)&quot; correspond au remplacement de la compression des textures en surbrillance.

Comme vous exécutez actuellement un GPU sur ordinateur, vous pouvez également améliorer la qualité graphique. Vous pouvez l'ajuster directement dans Paramètres du projet sous Qualité.

Capture d&#39;écran de la section &quot;Qualité&quot; dans les paramètres du projet

13. Félicitations

Vous disposez maintenant de tous les outils nécessaires pour commencer à travailler sur votre jeu pour Google Play Jeux. Vous pouvez commencer à tester votre jeu à plusieurs reprises. N'oubliez pas que même si vous pouvez conserver le même code base, vous devrez adapter votre jeu pour qu'il ressemble à un jeu PC natif.

Et ensuite ?

Il reste encore beaucoup à faire dans Google Play Jeux:

Enfin, le travail que vous avez accompli depuis le lancement de Google Play Jeux vous permet également d'utiliser ChromeOS. Il est conseillé d'envisager d'utiliser cette plate-forme conjointement avec les PC.