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 ?

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

Points abordés

Cet atelier de programmation couvre les parties de base de la checklist des exigences à respecter pour démarrer votre jeu et vous aider à préparer votre propre jeu Unity pour Google Play Jeux sur PC. Les intégrations plus avancées, telles que Play Games Sign-On et l'API Play Integrity, ne sont pas couvertes.

• Découvrez comment compiler pour l'architecture x86 d'Unity.
• Tester et déployer l'émulateur Google Play Jeux
• Comment modifier votre interface utilisateur pour qu'elle s'affiche correctement sur un PC.
• Découvrez comment détecter si votre jeu est en cours d'exécution dans l'émulateur Google Play Jeux et adapter votre jeu en conséquence.

Prérequis

• Installation LTS Unity 2020 (cet atelier de programmation a été créé avec 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 > (Fichier >) Paramètres de compilation et vérifiez que vous avez configuré la compilation 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 doit s'afficher dans une fenêtre:

Remarque:L'émulateur apparaît en tant qu'émulateur du développeur Google Play Jeux dans la liste d'applications.

Il s'agit d'un environnement Android hautes performances doté de fonctionnalités complètes, 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 avez besoin d'une version récente d'adb pour détecter l'émulateur. La version fournie avec Android Studio fonctionne, mais il se peut qu'adb tel qu'expédié avec Unity ne fonctionne pas. Une version compatible est fournie avec l'émulateur. Elle est disponible à l'adresse C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Pour une expérience optimale, nous vous recommandons 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 compiler et déployer directement sur l'émulateur (facultatif)

La version d'adb livrée avec Unity peut ne pas être compatible avec l'émulateur. Pour vous en assurer, sélectionnez Fichier -> Build Settings (Paramètres de compilation) et vérifiez si la boîte de dialogue Run Device (Exécuter l'appareil) s'affiche.

Attention:N'oubliez pas d'utiliser adb connect localhost:6520 avec la version d'adb fournie avec Unity si vous avez exécuté adb avant les tests. Au moment de la rédaction de ce document, aucune des versions Unity testées n'était fournie avec un adb compatible.

En fonction de votre projet, de votre processus de compilation et de votre 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.

Effectuez le déploiement directement sur l'émulateur en procédant comme suit:

1. Configurez Unity pour utiliser un autre SDK Unity, idéalement celui installé par Android Studio.
2. Mettez à jour Build Tools pour contourner un bug dans Unity.

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

1. Ouvrez Android Studio, puis sélectionnez Edit -> (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). Ne modifiez pas l'option Android NDK.

Lorsque vous actualisez les appareils connectés, Google HPE device (localhost:6520) doit apparaître 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é d'Unity prévaut jusqu'à ce que vous le modifiiez et que vous vous reconnectiez manuellement à la nouvelle instance adb.

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 un mainTemplate.gradle et un launcherTemplate.gradle.

3. Ouvrez la fenêtre Project Settings (Paramètres du projet) pour accéder à Player Settings (Paramètres du joueur), puis localisez la section Publishing Settings.
4. Faites défiler la page vers le bas 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 d'applications personnalisé), qui générera les deux fichiers Gradle sous Assets\Plugins\Android\.

Remarque:Les projets qui utilisent 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é auparavant, nous vous conseillons également de vérifier ce paramètre.

1. Remplacez n'importe quelle instance de la chaîne **BUILDTOOLS** par 30.0.0. Dans les deux fichiers, la section de code doit maintenant 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 en utilisant un appareil ChromeOS. Tout comme Google Play Jeux sur PC, les Chromebooks sont équipés de claviers et de souris, d'un grand écran et sont disponibles en configurations x86. Nous utiliserons 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.

Activez ensuite le débogage ADB.

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

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

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

5. Sélectionnez Fenêtre -> Analyse -> Android Logcat pour ouvrir la fenêtre Android Logcat

6. Ouvrez la liste des appareils. Le message No Device peut s'afficher si aucun appareil n'est 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 (Opération réussie) doit s'afficher:

Votre Chromebook apparaît désormais dans la liste "Exécuter les appareils" d'Unity (vous devrez peut-être d'abord actualiser l'écran):

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

6. Déployer un build de test

Google Play Jeux nécessite le déploiement d'une version x86 de votre jeu. Cela fait partie de la manière dont il atteindra ses benchmarks de performances sur les ordinateurs de bureau. Toutes les variantes LTS d'Unity peuvent générer des builds Android compatibles x86 et x86-64 (libellés "Chrome OS"), et Unity version 2018 et antérieures peuvent générer des builds x86. Pour débloquer ces architectures, vous devez d'abord passer au backend de script IL2CPP, ce que vous faites probablement déjà en production pour la compatibilité arm64.

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

2. Accédez à la section Other Settings (Autres paramètres) et définissez Scripting Backend sur IL2CPP.

Vous devez également activer la compatibilité x86 ou x86-64. Pour utiliser la plate-forme Google Play Jeux, vous ne devez accepter que x86, bien que nous vous recommandons d'utiliser x86-64.

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

La version des bundles Unity de la bibliothèque Frame Pacing 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 Paramètres du lecteur, ouvrez la section Résolution et présentation et décochez la case Frame Pacing optimisé.

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 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)" apparaît dans votre « Run Device » liste. S'il est absent, assurez-vous 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 votre liste d'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 -> (Outils ->) Ouvrez un terminal dans le répertoire contenant le même adb.exe que Unity.

Ouvrir le terminal" mis en surbrillance" style="largeur: 624.00px" src="img/9101ce3c95fb1aa2.png" img/9101ce. size="(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 connecter une souris et un clavier ou brancher un écran. Par conséquent, modifier votre schéma de commande ou les éléments HUD en fonction de la configuration de votre appareil vous permet de profiter du fonctionnement de Google Play Jeux sur PC sur toutes vos plates-formes compatibles.

S'il est judicieux de modifier la logique selon que le joueur utilise ou non 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 que votre HUD n'occupe pas plus de 20% de l'écran. Étant donné que de nombreux jeux mobiles utilisent l'option « Échelle avec la taille de l'écran », la remplacer par « Taille physique constante » ou "Taille constante en pixels" peut être un bon début pour atteindre cet objectif.

Vous pouvez également définir les paramètres de qualité de manière dynamique à 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 natives à partir des émission d'OpenGL Unity. Vous pouvez ainsi obtenir une fidélité graphique supérieure à celle disponible sur vos builds de jeu mobile.

8. Traitement des entrées

La livraison de jeux sur Google Play Jeux doit être axée sur la saisie à la souris et au clavier. Vous devrez prévoir comment interagir avec votre jeu à l'aide d'une souris et d'un clavier. Prenez donc le temps de vous procurer le package unitypackage du SDK Input. Si aucun téléchargement n'apparaît sur cette page, vérifiez que vous êtes connecté à un compte du groupe play-mp-libs.

À des fins de test, de nombreux jeux créent des commandes de base pour la souris et le clavier à des fins de développement dans l'éditeur. Si possible, vous pouvez les activer sur un appareil ChromeOS ou dans l'émulateur Google Play Jeux.

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

Par défaut, Google Play Jeux et ChromeOS convertissent la saisie avec la souris en une simulation de toucher. Si vous utilisez Input.GetTouch et Input.touchCount, votre jeu continue de fonctionner comme prévu. Si vous utilisez la saisie multipoint, comme les commandes à double pouce ou le pincement pour zoomer, vous devez mapper l'action aux appuis sur les touches. Vous devez également associer les actions dans le jeu aux pressions sur les 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 l'espace pour sauter. Si vous utilisez votre propre jeu, assurez-vous d'avoir vos combinaisons de touches préférées pour l'étape suivante.

9. Intégration du SDK Input

Maintenant que vous avez configuré les commandes de votre souris et de votre clavier, vous devez ajouter la compatibilité avec le SDK Input . Cela permet aux joueurs de découvrir les entrées de votre PC dans 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 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 Saut:

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 clavier 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, il n'y a qu'un seul groupe, mais vous pouvez en créer autant que nécessaire pour aider les joueurs à effectuer 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ées que vous avez créés au mappage d'entrées. Modifiez l'instruction return dans OnProvideInputMap comme suit:

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

6. Pour finir, ajoutez le script que vous avez créé dans votre jeu:

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

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

10. Supprimer les vues Web intégrées

Pour offrir une expérience optimale à vos joueurs, nous vous conseillons de supprimer les vues Web intégrées. Il est courant d'utiliser des vues Web intégrées pour afficher des éléments tels que vos règles de confidentialité ou vos conditions d'utilisation. Bien qu'elles fonctionnent dans Google Play Jeux, elles apparaissent dans un environnement "mobile" intégré au lieu du navigateur d'ordinateur 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é, utilisez 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, le build de votre PC ne doit jamais ouvrir de boîte de dialogue d'autorisation. Maintenant que votre build est prêt, nous vous conseillons d'effectuer une nouvelle installation standard et de noter toutes les boîtes de dialogue que vous voyez pour les ajouter à votre liste de tâches. pour envoyer votre jeu.

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

12. Optimisations pour les ordinateurs

Google Play Jeux présente quelques différences par rapport à un téléphone Android standard, et vous pouvez configurer votre jeu en conséquence.

Passez en mode DXT pour la compression de texture. Les formats de texture Android courants, tels que le format 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 joueur. ASTC offre la meilleure compatibilité avec les ordinateurs de bureau, mais vous devez utiliser un outil de profilage GPU pour ordinateur afin de vérifier le comportement attendu de votre jeu.

Étant donné que vous utilisez actuellement un GPU pour ordinateur, vous pouvez également améliorer la qualité graphique. Vous pouvez le modifier directement dans les paramètres du 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 et à itérer votre jeu. N'oubliez pas que même si vous pouvez conserver le même code base, vous devez adapter votre jeu pour qu'il ressemble à un jeu PC natif.

Et ensuite ?

Il y a encore beaucoup à faire pour proposer un jeu sur Google Play Jeux:

• Consultez le guide de démarrage rapide pour obtenir les dernières informations.
• Passez à Play Games Services Sign In v2 (Connexion aux services de jeux Play v2) pour connecter automatiquement un joueur au lancement et répondre aux exigences de continuité.
• Implémentez l'API Play Integrity pour vous assurer que votre expérience sur PC est aussi sécurisée que votre appareil mobile.

Enfin, l'essentiel du travail que vous avez fourni jusqu'ici pour assurer la compatibilité avec Google Play Jeux vous permet également de déployer votre application sur ChromeOS. Nous vous conseillons de prendre en charge cette plate-forme en plus des ordinateurs.