Conseils de test et d'assurance qualité pour les projets Unity

Le test est crucial pour découvrir des problèmes tels que des bogues dans votre code, des artefacts visuels dans l'art, ou des problèmes d'expérience utilisateur dans la conception et le gameplay du jeu. Vous pouvez développer le jeu le plus techniquement impressionnant, mais s'il plante neuf fois sur dix, vos utilisateurs vont rapidement abandonner.

Évitez de laisser les tests à la fin de votre processus de développement de jeu. Au lieu de considérer les tests comme une étape dans une séquence, il peut être utile de les voir comme un processus continu qui sous-tend les autres étapes du développement de jeu. Testez vos idées et prototypes tout au long de la production et avant de les expédier. Répétez ce processus pour chaque mise à jour que vous publiez pour votre jeu.

Il existe une gamme de techniques de test différentes qui pourraient mieux convenir à différentes étapes de votre projet.

Êtes-vous membre d'un petit studio sans équipe QA dédiée ? Faites appel à un groupe de travail d'amis pour vous aider avec les tests, ou choisissez un fournisseur QA tiers pour vous aider. Même les studios avec une équipe QA interne utiliseront souvent une entreprise externe pour des services de test supplémentaires, tels que le test de localisation (LQA).

Le test des joueurs, qui peut être considéré comme un sous-ensemble de la QA, aide à garantir que votre jeu résonne avec votre public cible et votre marché. C'est un processus qui peut fournir des retours précieux des joueurs pour améliorer le jeu pendant la phase de développement.

Les personnes qui devraient participer aux tests des joueurs varient en fonction des objectifs spécifiques des tests. Cependant, en général, il est important d'impliquer un groupe diversifié de joueurs qui représentent le public cible du jeu. En impliquant différents types de joueurs dans les tests des joueurs, les développeurs de jeux peuvent recueillir des retours de diverses perspectives et s'assurer que le jeu attire un large public.

Dans les sections suivantes, vous pouvez lire sur les techniques de test courantes. Ces méthodes peuvent être combinées pour garantir que votre code fonctionne aussi bien que possible.

Il est également important de tester le jeu sur une gamme d'appareils au sein de vos plateformes cibles. Cela s'appliquerait particulièrement aux jeux mobiles ; vous voudrez tester sur différents systèmes d'exploitation, tailles d'écran et les appareils mobiles les moins performants. Cela aidera à établir vos exigences minimales en matière d'appareils, et chaque catégorie devrait être constamment révisée lorsque vous ajoutez plus de fonctionnalités à votre application.

Tester sur diverses plateformes ne consiste pas seulement à identifier des problèmes potentiellement bloquants pour le jeu, il est également important de comprendre les implications à long terme ou indirectes, telles que la consommation de batterie ou la surchauffe thermique pour les jeux mobiles.

Les tests unitaires sont une technique qui consiste à tester des unités ou des composants individuels d'un jeu de manière isolée, aidant à s'assurer que les bogues sont détectés tôt dans le processus de développement et que les modifications du code ne cassent pas la fonctionnalité existante.

Les tests unitaires se font en écrivant de petits cas de test qui exercent des comportements spécifiques du code. Les tests peuvent être exécutés sur des scripts individuels, des GameObjects ou des fonctionnalités spécifiques du jeu.

Des méthodes manuelles et automatisées de tests unitaires doivent être utilisées dans le développement de jeux.

Tests unitaires manuels

Les tests manuels impliquent des personnes jouant au jeu pour tester ses fonctionnalités et sa fonctionnalité. Il est important d'effectuer des tests manuels car il existe des problèmes que les tests automatisés pourraient ne pas détecter, tels que des bogues d'interface utilisateur ou un gameplay ou un design déséquilibré ou mal exécuté.

Un exemple de test unitaire manuel dans Unity serait d'ajouter une condition de test pour une fonction et d'utiliser Debug.Log pour afficher les critères de réussite ou d'échec (la sortie des scénarios de test) en utilisant le mode Play d'Unity.

Tests unitaires automatisés

Les tests unitaires automatisés nécessitent d'écrire du code pour tester automatiquement des unités ou des morceaux de code de manière isolée. Dans Unity, vous pouvez écrire des tests pour des scripts, des composants et d'autres unités de code de jeu qui peuvent être exécutés dans le cadre d'une suite de tests.

Le package Unity Test Framework (UTF) fournit un cadre pour que les développeurs écrivent leurs propres tests automatisés à la fois en mode Édition et en mode Play dans l'éditeur Unity. UTF recherche un test dans toute assemblée qui référence NUnit. Ces assemblées sont appelées TestAssemblies. Les tests en mode Play et en mode Édition doivent être dans des assemblées séparées.

UTF fournit une fenêtre Test Runner dans l'éditeur pour vous aider à exécuter et à gérer vos cas de test.

Puisque UTF utilise une définition d'assemblée de test, vous devrez décomposer votre projet en définitions d'assemblée d'exécution. C'est plus facile à faire lorsque vous le planifiez tôt dans le processus de développement ; cela vous encourage également à écrire un code plus modulaire.

Le package Unity, Performance Testing Extension est une extension que vous pouvez utiliser avec l'UTF. Il fournit des API supplémentaires pour prendre des mesures et fournir des métriques personnalisées à partir de vos cas de test.

Apprenez à commencer avec le Unity Test Framework pour le développement de jeux vidéo en lisant le tutoriel.

Le développement piloté par les tests (TDD) est une technique qui consiste à écrire des tests pour une fonctionnalité avant d'écrire le code réel pour l'implémenter. Le processus implique généralement d'écrire un test échouant, d'écrire le minimum de code nécessaire pour faire passer le test, puis de refactoriser le code pour le rendre plus maintenable avant de passer à la conception du prochain cas de test.

Le TTD est assez rare dans le développement de jeux (il est plus courant dans le développement de logiciels grand public). Cela est probablement dû au fait que c'est un processus contre-intuitif pour le prototypage et la création d'un gameplay amusant et captivant.

Cependant, cela peut accélérer le processus d'identification des parties défectueuses de vos jeux, car tout changement qui casse le jeu créera immédiatement des cas de test échoués.

Pour en savoir plus sur le TDD dans Unity, consultez l'article de blog « Tester le développement piloté par les tests avec le Unity Test Runner. »

Couverture de code

Si vous souhaitez mettre en œuvre le TDD ou des tests unitaires, envisagez d'utiliser le package Code Coverage d'Unity. Lorsqu'il est utilisé avec l'UTF, le package Code Coverage peut vous montrer quelles lignes de code de votre projet sont testées pour vous aider à identifier les parties vulnérables ou non testées de votre projet.

Le Code Coverage peut également générer des rapports pendant que vous testez votre jeu en mode Play. Cela vous montrera les parties de votre code que vous exécutez régulièrement à travers des tests, même si elles ne sont pas couvertes par des tests unitaires. Cependant, bien que les rapports de Code Coverage vous montrent quelles lignes de code ont été couvertes dans votre test, ils ne vous montreront pas les différents chemins que la logique a empruntés dans le code.

Consultez l'article de blog « Code Coverage : Repérez les lacunes dans vos tests » pour plus d'informations.

Les tests d'intégration sont une technique qui teste différents composants d'un système ensemble pour s'assurer qu'ils fonctionnent correctement. Cela peut inclure le test de la façon dont différents GameObjects, scripts ou systèmes interagissent les uns avec les autres dans le jeu. En raison de son champ d'application plus large, les tests d'intégration peuvent aider à détecter des bogues qui peuvent ne pas apparaître dans les tests unitaires, tels que des problèmes de flux de données ou de communication entre les composants.

Par exemple, au lieu d'utiliser des tests unitaires individuels, un test d'intégration pourrait être écrit pour cette séquence entière : un joueur tirant une arme qui instancie une balle, la balle touchant un ennemi et le tuant, le joueur obtenant des points pour avoir tué l'ennemi, et un succès étant débloqué lorsque le joueur atteint un certain score.

Vous pouvez utiliser l'UTF pour créer des tests d'intégration dans Unity. En utilisant les méthodes SetUp et TearDown, vous pouvez créer un environnement pour tester plusieurs systèmes à la fois. La logique et l'entrée du joueur peuvent être simulées, surtout si vous les avez mises en œuvre en utilisant le Modèle de Commande (et si vous utilisez le nouveau Système d'Entrée, alors vous l'avez probablement fait), afin que vous puissiez tester le flux complet de l'entrée du joueur vers la logique du jeu.

Les tests de régression sont une méthode pour vérifier que les logiciels ou les fonctionnalités fonctionnent correctement après avoir été modifiés ou mis à jour. L'objectif des tests de régression est de s'assurer que les modifications apportées à la base de code n'introduisent pas de nouveaux bogues ou régressions dans le logiciel. Cette technique est mieux appliquée aux grandes applications complexes avec des mises à jour fréquentes, comme un jeu en direct, où il peut y avoir de nombreux composants différents qui peuvent interagir de manière inattendue.

À mesure que votre monde de jeu et vos mécaniques s'étendent, le besoin de tests de régression augmente également, ce qui peut en faire un coût élevé. Par conséquent, il est important de l'automatiser autant que possible. Les tests de régression doivent être effectués en parallèle avec le développement de nouvelles fonctionnalités, surtout si vous ciblez plusieurs plateformes.

Bien que les tests de régression soient mieux adaptés aux jeux plus grands et en direct, d'autres facteurs, tels que la complexité du logiciel, la fréquence des modifications ou des mises à jour, et l'importance critique des fonctionnalités affectées (systèmes critiques pour la mission ou la sécurité) déterminent également son besoin.

Les tests fonctionnels évaluent la fonctionnalité d'un système ou d'une application logicielle en le testant par rapport à ses exigences fonctionnelles. Cela implique de tester les fonctionnalités du système, les interfaces utilisateur, les interactions avec la base de données et d'autres aspects qui affectent son comportement et sa fonctionnalité. L'objectif des tests fonctionnels est de vérifier si le système ou l'application répond aux exigences et spécifications fournies par le client ou l'utilisateur final.

La plupart des tests unitaires se concentrent sur un chemin spécifique à travers le code, testant s'il renvoie les bonnes sorties en fonction de certaines entrées. Il n'est pas capable de tester si le jeu fait ce pour quoi il a été conçu.

Les tests fonctionnels sont l'approche pour cela. Chaque fonction ou fonctionnalité est comparée à la conception originale pour voir si la sortie répond aux attentes. Cela peut inclure le test des contrôles du jeu, des mécaniques de jeu et de l'expérience utilisateur globale.

Il peut être utile de garder les tests fonctionnels à l'esprit lors du développement de votre jeu et de créer des tâches avec l'approche « quand ceci, alors cela ». Par exemple, lorsque le joueur appuie sur la barre d'espace, le personnage doit sauter : Ceci est à la fois une instruction au développeur sur la façon dont il doit mettre en œuvre une fonctionnalité, et un critère d'acceptation pour le testeur. Parfois, une fonctionnalité peut inclure quelques critères d'acceptation liés, comme quand une fonctionnalité peut et ne peut pas être utilisée. Mais ils devraient généralement se concentrer sur un seul élément de fonctionnalité.

Les tests fonctionnels sont les plus puissants lorsque les exigences sont clairement définies et délimitées. Il peut donc être utile de faire appel à des freelances ou à des studios pour livrer des composants de votre gameplay ou des actifs de votre monde de jeu.

Vous pouvez exécuter à la fois des tests fonctionnels automatisés et manuels. Des tests « boîte noire » (testant le système sans connaissance de son fonctionnement interne) et des tests « boîte blanche » (testant le système avec connaissance de son fonctionnement interne) doivent être effectués.

Les tests de performance impliquent de tester le jeu pour s'assurer qu'il fonctionne de manière fluide et efficace sur différentes configurations matérielles et logicielles. Cela est étroitement lié à profilage et aux flux de travail d'optimisation des performances, et cette pratique peut aider à identifier les goulets d'étranglement de performance ou les problèmes qui peuvent affecter les performances du jeu.

L'objectif principal est d'évaluer la performance d'un système ou d'une application dans différentes conditions de charge. Dans le développement de jeux, les tests de performance mesurent si le jeu fonctionne à un niveau de performance acceptable, en termes de fréquence d'images, de réactivité et de stabilité, et utilise la mémoire de manière la plus efficace.

Différents types de tests de performance incluent :

• Tests de charge : Détermine comment le jeu se comporte lorsqu'il est soumis à des charges de travail lourdes
• Tests de stress : Évalue comment le jeu gère des situations inattendues, telles que des augmentations soudaines de l'activité des joueurs
• Tests d'endurance : Évalue comment le jeu se comporte sur de longues périodes de temps

Le Profiler Unity

L'outil Profiler dans Unity vous aide à analyser les performances de votre jeu pendant que vous le développez. Il fonctionne à la fois dans l'Éditeur, fournissant un aperçu pendant que vous développez, ou sur tout appareil connecté à votre machine par câble ou via un réseau local, fournissant une analyse précise de la façon dont votre jeu fonctionne sur un appareil cible.

Le Profiler peut être étendu pour personnaliser la présentation à la fois du type de données que vous souhaitez capturer et de la manière dont elles seront présentées visuellement dans la fenêtre du Profiler.

En savoir plus sur la personnalisation du Profiler lors de la session Unite 2022 « Comment personnaliser les métriques de performance dans le Profiler Unity. »

Vous pouvez également écrire vos propres outils pour créer des tests de performance automatisés. Pour une discussion intéressante sur la façon d'aborder cela, jetez un œil à la présentation des développeurs de Monument Valley, ustwo Games, de Unite 2022 : « Faire Alba : Comment construire un jeu en monde ouvert performant. »

Les tests ne se limitent pas à la recherche de bogues et à la surveillance des performances. Parfois, vous voudrez peut-être comparer deux versions d'une fonctionnalité de jeu pour déterminer laquelle suscite le plus d'engagement de la part des joueurs et fonctionne mieux. C'est ce qu'on appelle le test A/B.

Le test A/B est utile pour modifier les statistiques d'un personnage ou d'armes qui affecteraient l'équilibre de votre jeu mais où les mécaniques de jeu restent inchangées. D'autres exemples pourraient être des tests réalisés pour comparer l'efficacité de différents tutoriels, mécaniques de jeu ou interfaces utilisateur. En analysant les données collectées auprès des deux groupes, vous pouvez identifier quelle version du jeu ou de la fonctionnalité est plus efficace et prendre des décisions basées sur les données concernant les changements à intégrer dans le produit final.

Le test A/B implique d'assigner aléatoirement les joueurs à deux groupes : Un groupe joue la version originale du jeu ou de la fonctionnalité (le groupe de contrôle), tandis que l'autre groupe joue une version modifiée du jeu ou de la fonctionnalité (le groupe expérimental).

L'essentiel est de collecter des données sur la façon dont un petit groupe de joueurs a été affecté par les différents changements pour vous aider à prendre une décision de conception sur quelle approche publier en tant que mise à jour généralisée.

Le test A/B peut aider à améliorer l'expérience utilisateur et à augmenter l'engagement et la rétention des joueurs. Il est particulièrement utile pour les jeux qui ont de grandes bases d'utilisateurs, où même de petites améliorations de l'engagement ou de la rétention des utilisateurs peuvent avoir un impact significatif.

Le test A/B est généralement fourni en tant que service backend, les joueurs n'étant même pas conscients qu'ils utilisent une variante différente. Unity Gaming Services (UGS) dispose d'outils pour vous aider à réaliser des tests A/B dans votre jeu, dont vous pouvez en apprendre davantage ici. Vous pouvez également consulter les Cas d'utilisation UGS, une collection d'exemples pour nos services backend, pour explorer des exemples de la façon dont vous pourriez configurer des tests A/B dans un jeu.

Cloud Diagnostics Advanced est un outil de rapport et d'analyse des plantages, alimenté par Backtrace, qui s'intègre à Unity pour fournir aux développeurs des informations détaillées sur les plantages et les exceptions dans leurs jeux. Lorsqu'un plantage se produit, Cloud Diagnostics Advanced capture un instantané de l'état du jeu au moment du plantage, y compris des informations sur l'environnement, la pile d'appels, le tas et les registres. Cet instantané est ensuite envoyé aux serveurs de Backtrace, où il est analysé pour déterminer la cause profonde du plantage.

Cloud Diagnostics Advanced fournit également des outils d'analyse et de reporting détaillés, qui peuvent vous aider à identifier les tendances et les modèles dans les performances et la stabilité de vos jeux au fil du temps. Un algorithme de dé-duplication regroupe les plantages communs par leur cause profonde dans le code, ce qui peut être utilisé pour aider à prioriser les erreurs à corriger en premier pour améliorer la stabilité pour le plus grand nombre de joueurs possible.

Peu importe les techniques de test que vous utilisez, il est important d'avoir un plan en place pour la façon dont vous allez tester votre jeu, et de vous assurer que le test fait partie intégrante de votre processus de développement. En utilisant une combinaison de ces techniques, vous pouvez vous assurer que votre jeu Unity est de la plus haute qualité et prêt pour la production.

Une nouvelle série de livres électroniques pour les programmeurs est maintenant disponible gratuitement de la part d'Unity. Chaque guide est rédigé par des programmeurs expérimentés et fournit des meilleures pratiques pour des sujets spécifiques qui sont importants pour les équipes de développement.

Créez un guide de style C# : Écrivez un code plus propre qui évolue guide les équipes dans le développement d'un guide de style pour aider à unifier leur approche pour créer une base de code plus cohérente.

Améliorez votre code avec des modèles de programmation de jeux met en avant les meilleures pratiques pour utiliser les principes SOLID et les modèles de programmation courants pour créer une architecture de code de jeu évolutive dans votre projet Unity.

Créez une architecture de jeu modulaire dans Unity avec des ScriptableObjects fournit des meilleures pratiques pour déployer des ScriptableObjects dans la production de jeux.

Nous avons créé cette série pour fournir des conseils pratiques et de l'inspiration à nos créateurs les plus expérimentés. Mais ce ne sont pas des livres de règles ! Il existe de nombreuses façons de structurer votre projet Unity ; évaluez les avantages et les inconvénients de chaque recommandation, conseil et modèle avec vos collègues avant de le déployer.

Trouvez d'autres guides et articles avancés sur le hub des meilleures pratiques Unity.