Les tests sont essentiels pour découvrir des problèmes tels que des bogues dans votre code, des artefacts visuels dans les illustrations ou des problèmes d'expérience utilisateur dans la conception et le gameplay du jeu. Vous pouvez développer le jeu le plus impressionnant sur le plan technique, mais s'il se plante neuf fois sur dix, vos utilisateurs l'abandonneront assez rapidement.

Ne laissez pas les tests à la fin du processus de développement de votre jeu. Au lieu de considérer le test comme une étape dans une séquence, il peut être utile de le voir comme un processus continu qui sous-tend les autres étapes du développement d'un jeu. Testez vos idées et vos prototypes tout au long de la production et avant l'expédition. Répétez ce processus pour chaque mise à jour de votre jeu.

Il existe toute une série de techniques d'essai différentes qui peuvent être mieux adaptées aux différentes étapes de votre projet.

Vous faites partie d'un petit studio qui n'a pas d'équipe dédiée à l'assurance qualité ? Demandez à un groupe de travail composé d'amis de vous aider à effectuer les tests, ou choisissez un prestataire de services d'assurance qualité tiers pour vous aider. Même les studios qui disposent d'une équipe interne d'assurance qualité font souvent appel à une société externe pour des services de test supplémentaires, tels que les tests de localisation (LQA).

Le test des joueurs, qui peut être considéré comme un sous-ensemble de l'assurance qualité, permet de s'assurer que votre jeu trouve un écho auprès de votre public cible et de votre marché. C'est un processus qui permet d'obtenir un retour d'information précieux de la part des joueurs afin d'améliorer le jeu au cours de la phase de développement.

Les personnes qui doivent 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, les développeurs de jeux peuvent recueillir des commentaires de différents points de vue et s'assurer que le jeu plaît à un large public.

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

Il est également important de tester le jeu sur une série d'appareils appartenant aux plates-formes ciblées. Cela s'applique tout particulièrement aux jeux mobiles ; vous devrez les tester sur différents systèmes d'exploitation, différentes tailles d'écran et sur les appareils mobiles les moins performants. Cela vous aidera à définir les exigences minimales de votre appareil, et chaque catégorie doit être constamment réexaminée lorsque vous ajoutez de nouvelles fonctionnalités à votre application.

Les tests sur différentes plateformes ne servent pas seulement à identifier les problèmes potentiels de rupture de jeu, il est également important de comprendre les implications indirectes ou à long terme, telles que l'épuisement de la 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, ce qui permet de s'assurer que les bogues sont détectés à un stade précoce du processus de développement et que les modifications apportées au code ne cassent pas les fonctionnalités existantes.

Les tests unitaires sont effectués en écrivant de petits cas de test qui exercent des comportements spécifiques du code. Les tests peuvent porter sur des scripts individuels, des objets de jeu ou des caractéristiques spécifiques du jeu.

Les méthodes manuelles et automatisées de tests unitaires doivent être utilisées dans le développement d'un jeu.

Tests unitaires manuels

Les tests manuels impliquent que des personnes jouent au jeu pour tester ses caractéristiques et ses fonctionnalités. 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 bugs 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 (les résultats des scénarios de test) en utilisant le mode Play d 'Unity.

Tests unitaires automatisés

Les tests unitaires automatisés nécessitent l'écriture d'un code pour tester automatiquement des unités individuelles 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 permettant aux développeurs d'écrire leurs propres tests automatisés en mode édition et en mode lecture dans l'éditeur Unity. UTF recherche un test dans n'importe quel assemblage qui fait référence à NUnit. Ces assemblages sont appelés assemblages de test. Les tests en mode lecture et en mode édition doivent se trouver dans des assemblages distincts.

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

Comme l'UTF utilise une définition d'assemblage de test, vous devrez décomposer votre projet en définitions d'assemblages d'exécution. Il est plus facile de le faire lorsque vous le planifiez dès le début du processus de développement ; cela vous encourage également à écrire un code plus modulaire.

Le paquet 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 à démarrer avec Unity Test Framework en lisant le tutoriel Unity Test Framework pour le développement de jeux vidéo.

Le développement piloté par les tests (TDD) est une technique qui consiste à écrire des tests pour un élément de fonctionnalité avant d'écrire le code réel pour le mettre en œuvre. Le processus consiste généralement à écrire un test qui échoue, à écrire la quantité minimale de code nécessaire pour que le test réussisse, puis à remanier le code pour le rendre plus facile à maintenir avant de passer à la conception du cas de test suivant.

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 qu'il s'agit d'un processus contre-intuitif pour le prototypage et l'élaboration d'un gameplay amusant et convaincant.

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

Pour en savoir plus sur le TDD dans Unity, consultez l'article de blog "Testing Test-Driven Development with the Unity Test Runner".

Couverture de code

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

Code Coverage peut également générer des rapports pendant que vous testez votre jeu en mode Play. Cela vous permettra de voir les parties de votre code que vous testez régulièrement, même si elles ne sont pas couvertes par les tests unitaires. Toutefois, si les rapports sur la couverture du code vous indiquent les lignes de code couvertes par votre test, ils ne vous montrent pas les différentes voies empruntées par la logique dans le code.

Voir l'article de blog "Code Coverage : Repérer les lacunes dans vos tests" pour plus d'informations.

Le test d'intégration est une technique qui permet de tester ensemble les différents composants d'un système afin de s'assurer qu'ils fonctionnent correctement. Il peut s'agir de tester la façon dont différents objets de jeu, scripts ou systèmes interagissent les uns avec les autres dans le jeu. En raison de leur portée plus large, les tests d'intégration peuvent aider à détecter des bogues qui ne seraient pas apparus lors des 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 l'ensemble de cette séquence : un joueur tirant avec 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 une réalisation se débloquant lorsque le joueur atteint un certain score.

Vous pouvez utiliser UTF pour construire des tests d'intégration dans Unity. Les méthodes SetUp et TearDown permettent de créer un environnement pour tester plusieurs systèmes à la fois. La logique et les entrées des joueurs peuvent être simulées, en particulier si vous les avez implémentées en utilisant le modèle de commande (et si vous utilisez le nouveau système d'entrée, c'est probablement le cas), afin de tester le flux complet des entrées des joueurs dans la logique du jeu.

Le test de régression est une méthode permettant de vérifier que le logiciel 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 de régressions dans le logiciel. Cette technique s'applique le mieux aux applications complexes et de grande envergure 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.

Au fur et à mesure que l'univers et les mécanismes de votre jeu se développent, les tests de régression deviennent de plus en plus nécessaires, ce qui peut s'avérer coûteux. Il est donc important de l'automatiser dans la mesure du possible. Les tests de régression doivent être effectués parallèlement au développement de nouvelles fonctionnalités, en particulier si vous visez plusieurs plateformes.

Si les tests de régression conviennent mieux aux jeux de grande envergure et aux jeux en direct, d'autres facteurs, tels que la complexité du logiciel, la fréquence des changements ou des mises à jour et l'importance critique des fonctionnalités concernées (systèmes essentiels à la mission ou à la sécurité), en déterminent également la nécessité.

Les tests fonctionnels évaluent la fonctionnalité d'un système ou d'une application logicielle en le testant par rapport à ses exigences fonctionnelles. Il s'agit de tester les caractéristiques 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 aux 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, en testant s'il renvoie les résultats corrects en fonction de certaines entrées. Il n'est pas en mesure de vérifier si le jeu fait ce pour quoi il a été conçu.

Les tests fonctionnels constituent l'approche idéale. Chaque fonction ou caractéristique est comparée à la conception d'origine pour voir si le résultat correspond aux attentes. Il peut s'agir de tester les commandes du jeu, les mécanismes de jeu et l'expérience globale de l'utilisateur.

Il peut être utile de garder à l'esprit les tests fonctionnels lors du développement de votre jeu et de créer des tâches selon l'approche "quand ceci, alors cela". Par exemple, lorsque le joueur appuie sur la barre d'espacement, le personnage doit sauter : Il s'agit à la fois d'instructions données au développeur sur la manière dont il doit mettre en œuvre une fonctionnalité et d'un critère d'acceptation que le testeur doit vérifier. Parfois, une fonctionnalité peut inclure quelques critères d'acceptation connexes, tels que le moment où une fonctionnalité peut ou ne peut pas être utilisée. Mais ils doivent généralement se concentrer sur une seule fonctionnalité.

Les tests fonctionnels sont plus efficaces lorsque les exigences sont clairement définies et délimitées. Il peut donc être utile pour passer des contrats avec des indépendants ou des studios afin de fournir des éléments de votre gameplay ou de votre univers de jeu.

Vous pouvez effectuer des tests fonctionnels automatisés et manuels. Il convient d'effectuer à la fois des tests "boîte noire" (tester le système sans connaître son fonctionnement interne) et des tests "boîte blanche" (tester le système en connaissant son fonctionnement interne).

Le test de performance consiste à tester le jeu pour s'assurer qu'il fonctionne de manière fluide et efficace sur différentes configurations matérielles et logicielles. Cette pratique est étroitement liée au profilage et aux flux de travail généraux d'optimisation des performances, et elle peut aider à identifier les goulets d'étranglement ou les problèmes susceptibles d'avoir un impact sur les performances du jeu.

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

Les différents types de tests de performance sont les suivants

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

Le profileur Unity

L'outil Profiler d'Unity vous aide à analyser les performances de votre jeu au fur et à mesure que vous le développez. Il fonctionne à la fois dans l'éditeur, offrant une vue d'ensemble pendant que vous développez, ou sur n'importe quel appareil connecté à votre machine par câble ou via un réseau local, offrant 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 du type de données que vous souhaitez capturer et la manière dont elles seront présentées visuellement dans la fenêtre du Profiler.

Pour en savoir plus sur la personnalisation du Profiler, consultez la session Unite 2022 "Comment personnaliser les mesures de performance dans le Profiler Unity".

Vous pouvez également créer vos propres outils pour automatiser les tests de performance. Pour une discussion intéressante sur la manière d'aborder cette question, jetez un œil à l'exposé des développeurs de Monument Valley, ustwo Games, à l'occasion de l'événement Unite 2022 : "Making Alba : Comment construire un jeu à monde ouvert performant."

Les tests ne se limitent pas à la recherche de bogues et au contrôle des performances. Il peut arriver que vous souhaitiez comparer deux versions d'une fonctionnalité de jeu afin de déterminer celle qui suscite le plus d'engagement de la part des joueurs et qui est la plus performante. C'est ce qu'on appelle les tests A/B.

Les tests A/B sont utiles pour modifier les statistiques d'un personnage ou d'une arme, ce qui aurait un impact sur l'équilibre du jeu, mais dont les mécanismes restent inchangés. D'autres exemples peuvent être des tests menés pour comparer l'efficacité de différents tutoriels, mécanismes de jeu ou interfaces utilisateur. En analysant les données recueillies auprès des deux groupes, vous pouvez déterminer quelle version du jeu ou de la fonction est la plus efficace et prendre des décisions fondées sur des données quant aux changements à intégrer dans le produit final.

Les tests A/B consistent à répartir les joueurs de manière aléatoire dans 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 recueillir des données sur la façon dont une petite cohorte de joueurs a été affectée par les différents changements afin de vous aider à prendre une décision sur l'approche à adopter pour une mise à jour généralisée.

Les tests A/B peuvent contribuer à améliorer l'expérience de l'utilisateur et à accroître l'engagement et la fidélisation des joueurs. Elle est particulièrement utile pour les jeux qui ont de grandes bases d'utilisateurs, où même de petites améliorations dans l'engagement ou la fidélisation des utilisateurs peuvent avoir un impact significatif.

Les tests A/B sont généralement fournis en tant que service d'arrière-plan, les joueurs ne sachant même pas qu'ils utilisent une variante différente. Unity Gaming Services (UGS) dispose d'outils pour vous aider à effectuer des tests A/B dans votre jeu, que vous pouvez découvrir ici. Vous pouvez également consulter les cas d'utilisation UGS, une collection d'exemples pour nos services backend, afin d'explorer des exemples de la manière dont vous pourriez mettre en place des tests A/B dans un jeu.

Cloud Diagnostics Advanced est un outil de reporting et d'analyse des crashs, alimenté par Backtrace, qui s'intègre à Unity pour fournir aux développeurs des informations détaillées sur les crashs et les exceptions dans leurs jeux. Lorsqu'un crash se produit, Cloud Diagnostics Advanced capture un instantané de l'état du jeu au moment du crash, 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é afin de déterminer la cause première de la panne.

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 de performance et de stabilité de vos jeux au fil du temps. Un algorithme de déduplication regroupe les pannes courantes en fonction de leur cause première dans le code, ce qui peut aider à déterminer les erreurs à corriger en priorité afin d'améliorer la stabilité pour le plus grand nombre de joueurs possible.

Quelles que soient les techniques de test que vous utilisez, il est important de mettre en place un plan pour tester votre jeu et de veiller à ce que les tests fassent 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 destinés aux programmeurs est désormais disponible gratuitement auprès d'Unity. Chaque guide est rédigé par des programmeurs expérimentés et fournit les meilleures pratiques sur des sujets spécifiques importants pour les équipes de développement.

Créer un guide de style C# : Écrire un code plus propre et évolutif guide les équipes dans l'élaboration d'un guide de style afin d'unifier leur approche et de créer une base de code plus cohérente.

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

Créer une architecture de jeu modulaire dans Unity avec ScriptableObjects fournit les meilleures pratiques pour déployer les 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 les mettre en œuvre.

Vous trouverez des guides et des articles plus avancés sur le hub des meilleures pratiques Unity.