Développer des jeux pour tous les écrans

Lorsque vous développez un jeu pour Android, il est important d'anticiper les diverses expériences de jeu possibles et de vous adapter aux besoins d'interaction en temps réel des joueurs. En proposant différentes expériences de jeu, vous améliorez la flexibilité de jeu et élargissez votre audience.

Parmi les différences en termes d'expérience de jeu, on trouve par exemple les différences suivantes :

  • Facteurs de forme des appareils : bien que les téléphones proposent l'expérience traditionnelle que l'on trouve sur les appareils Android, il est possible d'interagir avec des jeux sur des appareils ayant d'autres facteurs de forme. Les appareils ChromeOS peuvent exécuter un conteneur Android qui affiche votre jeu. Les tablettes qui exécutent Android prennent en charge différents niveaux de fidélité. Les appareils Android TV offrent une expérience plus riche et plus immersive. Les joueurs peuvent simuler un environnement multifenêtre à l'aide d'un outil d'extension d'affichage. Lorsqu'ils utilisent des pliables, les joueurs peuvent modifier la taille de l'écran pendant une session de jeu.
  • Méthodes d'interaction : les joueurs peuvent interagir en appuyant sur l'écran d'un appareil, mais ils peuvent également utiliser une souris, un pavé tactile, un clavier ou une manette. De plus, la disponibilité d'outils d'extension d'écran et d'appareils pliables permet aux joueurs de profiter de votre jeu sur un plus grand écran, ce qui facilite la mise en œuvre d'interfaces plus complexes et permet aux joueurs de jouer plus longtemps.
  • Compatibilité matérielle : certains appareils Android ne possèdent pas le matériel que l'on trouve couramment sur les appareils portables, par exemple une caméra arrière, un GPS et une connectivité réseau. Votre jeu doit s'adapter au matériel présent et gérer correctement les cas où certaines fonctionnalités ne sont pas disponibles.

Ce guide présente les bonnes pratiques relatives au développement de votre jeu pour différents types d'écrans et d'interactions utilisateur. Ce guide fournit également des suggestions pour concevoir votre jeu et développer une stratégie de test efficace.

Bonnes pratiques pour la conception de jeux

Lorsque vous planifiez la conception et l'architecture de votre jeu, adoptez les bonnes pratiques décrites dans les sections suivantes.

Répondre manuellement aux modifications de configuration

Lorsque le système Android détecte une modification de la configuration, telle qu'un changement de taille ou d'orientation d'écran, ou de mode de saisie, il redémarre par défaut l'activité en cours. Par défaut, pour conserver l'état d'une application ou d'un jeu, l'activité appelle respectivement onSaveInstanceState() et onRestoreInstanceState() avant et après son redémarrage. Toutefois, ce processus nécessite que l'activité actualise toutes les ressources et tous les services associés. Pour en savoir plus sur ce comportement par défaut, consultez le guide sur la gestion des modifications de configuration.

Une session de jeu type subit plusieurs modifications de configuration. Si votre jeu laisse le système gérer chaque modification de configuration, la scène est détruite et redémarrée à plusieurs reprises, ce qui réduit les performances du jeu. C'est pourquoi nous vous encourageons vivement à gérer vous-même ces modifications de configuration dans votre jeu.

Pour savoir comment ajouter cette logique de modification de configuration à votre jeu, consultez la section expliquant comment créer des gestionnaires de modifications de configuration personnalisés.

Créer une architecture flexible

Pour que votre jeu soit compatible avec le plus grand nombre d'appareils possible, suivez ces bonnes pratiques :

  • Déployez des Android App Bundle au lieu d'APK individuels. Les Android App Bundles vous permettent de regrouper des artefacts de différentes résolutions et différents modèles d'architecture, tels que x86 et ARM, dans un seul artefact. Mieux encore, les Android App Bundles acceptent des limites de taille plus élevées pour votre jeu. La taille de chaque APK de base peut atteindre 150 Mo, et celle du bundle lui-même peut atteindre plusieurs gigaoctets.
  • Ajoutez la compatibilité avec les architectures x86. Cette étape améliore les performances de votre jeu sur les appareils non compatibles avec ARM, car ces appareils peuvent désormais exécuter des instructions sans avoir à les traduire au préalable.

Ajouter la compatibilité avec Vulkan

En prenant en charge Vulkan, vous pouvez améliorer les performances graphiques de votre jeu. La plupart des appareils sont compatibles avec cette API graphique.

Créer des gestionnaires de modifications de configuration personnalisés

Pour déclarer les types de modifications de configuration que votre jeu gère lui-même, ajoutez l'attribut android:configChanges à chaque élément <activity> qui représente un écran ou une interface complexe.

L'extrait de code suivant montre comment déclarer que votre jeu prend en compte la modification de la taille et de l'orientation de l'écran, ainsi que les modifications du mode de saisie :

<activity ...
    android:configChanges="screenSize|orientation|keyboard|keyboardHidden">
</activity>

Lorsque les modifications de configuration déclarées se produisent, le système appelle désormais une autre méthode, onConfigurationChanged(). Dans cette méthode, ajoutez une logique pour mettre à jour l'interface utilisateur de votre jeu :

Gérer les modifications de configuration de l'écran

Votre jeu gère manuellement la taille et l'orientation de l'écran chaque fois que vous incluez les valeurs screenSize et orientation, respectivement, dans un attribut android:configChanges. Vous pouvez utiliser ces nouvelles valeurs pour mettre à jour le contenu de votre scène et les zones de saisie du joueur. Pour savoir comment concevoir la mise en page de votre jeu pour faciliter sa modification, consultez le guide de prise en charge de différentes tailles d'écran.

Dans l'implémentation de onConfigurationChanged() au sein de votre jeu, utilisez l'objet Configuration transmis et l'objet Display du gestionnaire de fenêtre pour déterminer respectivement les valeurs modifiées pour la taille et pour l'orientation de l'écran.

L'extrait de code suivant montre comment obtenir les nouvelles taille et orientation d'écran de votre jeu :

Kotlin

override fun onConfigurationChanged(newConfig: Configuration) {
    super.onConfigurationChanged(newConfig)
    val density: Float = resources.displayMetrics.density
    val newScreenWidthPixels = (newConfig.screenWidthDp * density).toInt()
    val newScreenHeightPixels = (newConfig.screenHeightDp * density).toInt()

    // Get general orientation; either Configuration.ORIENTATION_PORTRAIT or
    // Configuration.ORIENTATION_LANDSCAPE.
    val newScreenOrientation: Int = newConfig.orientation

    // Get general rotation; one of: ROTATION_0, ROTATION_90, ROTATION_180,
    // or ROTATION_270.
    val newScreenRotation: Int = windowManager.defaultDisplay.rotation
}

Java

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    float density = getResources().getDisplayMetrics().density;
    int newScreenWidthPixels = (int) (newConfig.screenWidthDp * density);
    int newScreenHeightPixels = (int) (newConfig.screenHeightDp * density);

    // Get general orientation; either Configuration.ORIENTATION_PORTRAIT or
    // Configuration.ORIENTATION_LANDSCAPE.
    int newScreenOrientation = newConfig.orientation;

    // Get general rotation; one of: ROTATION_0, ROTATION_90, ROTATION_180,
    // or ROTATION_270.
    int newScreenRotation = getWindowManager().getDefaultDisplay()
            .getRotation();
}

Notez que la modification de la position (déplié/plié) d'un appareil pliable modifie la configuration, même si votre application s'exécute en mode plein écran. Par conséquent, votre application peut avoir à gérer des modifications de la taille d'écran ou de la densité en pixels si l'utilisateur plie ou déplie l'appareil pendant que votre jeu est en cours d'exécution.

Qualités d'écran propres au jeu

Les sections suivantes décrivent comment ajuster la réaction de votre jeu aux changements de taille ou d'orientation de l'écran, en fonction des qualités de votre jeu :

Mode Plein écran

Sur certaines plates-formes, telles que ChromeOS, les applications et les jeux Android peuvent être affichés dans une fenêtre et redimensionnés par défaut. Si votre jeu doit toujours fonctionner en mode plein écran, vous pouvez définir l'attribut android:resizeableActivity sur false dans l'un de vos éléments <activity>, comme illustré dans l'extrait de code suivant :

<activity ...
    android:resizeableActivity="false">
</activity>

Vous pouvez également définir l'attribut android:resizeableActivity sur false pour empêcher les modifications de configuration liées à la taille de l'écran. Cependant, sauf si votre jeu fonctionne toujours en mode plein écran, vous ne devez ajouter cet attribut que comme solution temporaire à des fins de test.

Orientation de l'écran

Si votre jeu dépend de l'orientation spécifique des capteurs d'un appareil, spécifiez une valeur pour android:screenOrientation dans l'activité du jeu, comme indiqué dans l'extrait de code suivant. Ce paramètre permet d'éviter qu'une scène de votre jeu ne s'affiche à l'envers de manière inattendue.

<activity ...
    android:screenOrientation="landscape">
</activity>

Qualités d'écran propres à l'appareil

Les sections suivantes décrivent comment gérer les modifications de configuration liées à l'écran en fonction des qualités spécifiques de certains appareils.

Format

Certains appareils sont compatibles avec différents formats. Par exemple, les appareils pliables sont conçus pour être compatibles avec un format 21:9 lorsqu'ils sont pliés. Pour gérer cette variété potentielle de formats, effectuez au moins l'une des opérations suivantes :

  • Ciblez Android 8.0 (niveau d'API 26) ou version ultérieure.
  • Faites en sorte que la scène et l'interface de votre jeu soient redimensionnables. Définissez android:resizeableActivity sur true sur les appareils équipés d'Android 7.0 (niveau d'API 24) ou version ultérieure.

  • Déclarez un format maximum compatible. Dans un attribut <meta-data> associé à votre jeu, définissez android.max_aspect sur 2.4, comme indiqué dans l'extrait de code suivant. Toutefois, n'oubliez pas que les formats supérieurs à ceux que vous avez spécifiés entraîneront l'affichage du jeu au format letterbox sur un écran.

    <application>
<meta-data android:name="android.max_aspect"
           android:value="2.4" />
</application>

Activités multiples visibles simultanément

De nombreux appareils modernes sont compatibles avec de nombreuses mises en page d'écran, y compris le mode Écran partagé, Picture-in-picture et les grandes zones d'affichage. Lorsque vous utilisez l'une de ces mises en page, le système peut rendre plusieurs activités visibles en même temps.

Sur les appareils équipés d'Android 9 (niveau d'API 28) ou version ultérieure, il est possible d'activer la reprise de toutes les principales activités visibles en même temps. Toutefois, pour que ce comportement fonctionne, cette fonctionnalité doit être activée dans votre jeu, mais aussi par l'OEM de l'appareil. Vous pouvez ajouter la compatibilité au sein de votre jeu en définissant android.allow_multiple_resumed_activities sur true dans le fichier manifeste de votre jeu, comme indiqué dans l'extrait suivant :

<application>
    <meta-data android:name="android.allow_multiple_resumed_activities"
               android:value="true" />
</application>

Vous pouvez ensuite tester votre jeu sur différents appareils pour voir lesquels d'entre eux offrent la compatibilité OEM nécessaire pour que la multireprise fonctionne correctement.

Pour savoir comment configurer votre jeu pour qu'il apparaisse dans un affichage multifenêtre, consultez le guide sur l'ajout de la prise en charge du mode multifenêtre.

Gérer différents types de modèles d'interaction

Votre jeu gère manuellement la présence et la disponibilité du clavier chaque fois que vous incluez respectivement les valeurs keyboard et keyboardHidden dans un attribut android:configChanges. Ces nouvelles valeurs vous permettent de mettre à jour le mode de saisie principal de votre jeu.

Lorsque vous configurez votre jeu pour qu'il accepte plusieurs types d'entrées utilisateur, tenez compte des points suivants :

  • Détectez les modes de saisie plutôt que les appareils individuels. Cet état d'esprit permet d'améliorer plus facilement l'expérience du joueur sans se concentrer trop sur l'appareil spécifique dont il pourrait disposer.
  • Incluez l'attribut keyboardHidden dans votre liste de modifications de configuration gérées manuellement. De cette façon, votre jeu peut détecter quand un clavier est physiquement connecté à l'appareil, mais inutilisable.

  • Déterminez les modes de saisie actuellement disponibles. Pour ce faire, appelez getInputDeviceIds() au démarrage du jeu et après chaque modification de configuration.

    Vous pouvez souvent déterminer la manière dont le joueur prévoit d'interagir avec votre jeu en fonction de son périphérique d'entrée :

    • Les joueurs utilisent généralement un clavier ou une manette de jeu pour exécuter des séquences de boutons rapides.
    • Les joueurs utilisent généralement un écran tactile ou un pavé tactile pour effectuer des gestes plus complexes.
    • Les joueurs utilisent généralement la souris pour effectuer une saisie plus précise.

Les sections suivantes fournissent des bonnes pratiques pour des types spécifiques de périphériques d'entrée.

Clavier

Lorsque vous créez une disposition de clavier pour votre jeu, tenez compte de la façon dont le joueur parcourt une scène donnée, ainsi que de la manière dont il interagit avec les paramètres de votre jeu.

Les touches WASD ou les touches fléchées sont généralement plus efficaces pour contrôler le mouvement des personnages. Il est également préférable d'attribuer une touche particulière à chaque action ou compétence importante qu'un personnage contrôlable peut effectuer dans votre jeu. Pour optimiser l'expérience du joueur, envisagez d'ajouter la compatibilité avec les combinaisons personnalisées de touches dans votre jeu.

Les joueurs doivent également pouvoir ouvrir les menus du jeu et les parcourir à l'aide du clavier. La touche Esc est un mappage courant pour mettre en pause une scène et afficher le menu du jeu.

Pour en savoir plus sur la prise en charge de la saisie au clavier dans votre jeu, consultez le guide sur la prise en charge de la navigation au clavier ainsi que le guide sur la gestion des actions du clavier

Manette de jeu

Pour plus d'informations sur la gestion des manettes de jeu dans votre jeu, consultez le guide de prise en charge des manettes de jeu.

Souris ou pavé tactile

Si votre jeu est compatible avec la saisie depuis une souris ou un pavé tactile, n'oubliez pas que les joueurs interagissent avec l'appareil autrement qu'en jouant à votre jeu. Il est important de noter que, lorsque vous demandez la capture du pointeur, toutes les entrées de la souris sont dirigées vers votre jeu. Par conséquent, une fois que votre jeu dispose des informations nécessaires, relâchez la capture du pointeur pour que les joueurs retrouvent le contrôle standard de la souris sur leur appareil.

Sur les appareils équipés d'Android 8.0 (niveau d'API 26) ou version ultérieure, vous pouvez utiliser l'API Mouse Capture pour faciliter le processus de capture du pointeur. Dans les jeux qui réagissent à une entrée de haute précision, vous pouvez obtenir les coordonnées actuelles du pointeur en appelant les méthodes getX() et getY().

Pour plus d'informations sur la prise en charge de la saisie à la souris et au pavé tactile dans votre jeu, consultez le guide sur le suivi des mouvements tactiles et du pointeur, ainsi que le guide sur la gestion des gestes à plusieurs doigts.

Tester votre jeu

Avant de lancer votre jeu, testez ses réactions aux modifications de configuration en suivant la procédure décrite dans les sections suivantes.

Mettre à jour votre plan de test

Lorsque vous validez le fonctionnement de votre jeu, incluez les scénarios de test suivants :

  • Réduisez et agrandissez la fenêtre qui contient votre jeu. (Cela ne s'applique pas si votre jeu est toujours en mode plein écran.)
  • Modifiez la taille de l'écran.
  • Modifiez l'orientation de l'écran. (Ne s'applique pas si votre jeu a une orientation fixe.)
  • Connectez et déconnectez des périphériques d'entrée, tels que des claviers et des souris.
  • Effectuez une multireprise, si votre jeu le permet.

Envisagez également de mettre à jour le système de contrôle qualité de votre jeu afin de l'optimiser pour un plus large éventail d'expériences de jeu.

Pour connaître les bonnes pratiques liées au test de votre jeu, consultez le guide des principes de base des tests.

Utiliser les outils de test et de débogage

Vous pouvez effectuer des tests à l'aide des différents outils compatibles avec la plate-forme :