Lisez la suite pour apprendre comment améliorer votre processus QA et de débogage avec la classe Debug de Unity.
Bien que vous soyez peut-être déjà familier avec la fonction Debug.Log, la classe Debug de Unity prend en charge de nombreuses autres fonctions pratiques qui peuvent vous aider à accélérer vos tests et votre débogage. Cette page explique comment utiliser la classe Debug pour la visualisation des gizmos dans les vues Scene et Game, pour mettre en pause le mode Play dans l'éditeur à partir d'un script, et d'autres conseils.
Si vous êtes expérimenté avec Unity, vous avez probablement utilisé la fenêtre Console pour afficher les erreurs, avertissements et autres messages générés par l'éditeur. Vous avez également certainement imprimé vos propres messages dans la Console en utilisant la classe Debug.
Mais vous n'êtes pas limité uniquement au message Debug.Log. Lorsque vous créez des chaînes de sortie dans la fenêtre Console, vous pouvez spécifier l'un des trois types (erreur, avertissement et message), chacun avec son propre type d'icône.
Les trois variantes sont :
Vous pouvez utiliser la fenêtre Console pour filtrer les messages en fonction de vos préférences. Vous pouvez également profiter de l'activation de la pause d'erreur dans la fenêtre Console, car toutes les erreurs que vous écrivez dans la Console via la classe Debug provoqueront une pause du mode Play de Unity.
Tout ce qui est affiché dans la fenêtre Console, que ce soit par Unity ou vos propres messages, est ajouté à un Fichier Log auquel vous pouvez vous référer pour voir où des problèmes se sont produits dans votre application. Chaque système d'exploitation stocke les fichiers journaux à des emplacements différents, alors vérifiez la documentation pour voir les spécifications de chaque système.
Lorsqu'une erreur ou une exception est levée, la fenêtre Console affiche la trace de la pile avec le message d'erreur pour vous aider à comprendre comment l'erreur s'est produite et d'où elle provient. Alors que Debug.Log vous permet d'envoyer un message à la Console, vous pouvez également configurer le niveau de détail affiché dans la trace de la pile.
Par défaut, la sortie dans la Console est liée à la ligne de code qui a généré le message, ce qui facilite l'identification de la ligne, de la méthode ou de la séquence d'appels de fonction qui a causé l'entrée à apparaître.
Si le script ne s'ouvre pas dans votre IDE choisi, allez à Fichier > Préférences > Outils externes et sélectionnez le “Éditeur de script externe” dans le menu déroulant.
Vous pouvez configurer les informations affichées dans la trace de la pile via Fichier > Paramètres de construction… > Paramètres du joueur… > Autres paramètres dans l'Éditeur.
Les options suivantes sont disponibles pour chaque type de journal :
Utilisez la fonction de recherche dans la Console si votre journal devient encombré. Au fur et à mesure que vous tapez un terme de recherche, la Console filtre les messages pour n'afficher que ceux contenant le texte correspondant.
Contrôlez combien de lignes de chaque entrée sont visibles dans la liste en cliquant sur le bouton de menu de la Console et en sélectionnant Entrée de journal > [X] Lignes dans le menu, où [X] est le nombre de lignes à afficher pour chaque entrée.
La méthode String.Format en C# vous permet de créer une chaîne avec des données de variable formatées intégrées. La classe Debug a Debug.LogFormat, qui utilise la même syntaxe.
Le premier paramètre est la chaîne de message formatée. En incluant une valeur d'index entre accolades, cela sera remplacé par l'index du paramètre moins 1 en utilisant sa méthode ToString, si elle existe, ou la conversion de chaîne System. Dans l'exemple de code ci-dessus, la ligne 14, {0} sera remplacé par origin.ToString().
Un exemple plus complexe est celui-ci :
Debug.LogFormat("Au début transform.position={0}, transform.rotation={1}", transform.position, transform.rotation);
{0} sera remplacé par le paramètre 1, transform.position et {1} sera remplacé par le paramètre 2, transform.rotation. Dans chaque cas, la méthode ToString des propriétés Vector3 et Quaternion sera utilisée. Le résultat ressemblera à ceci :
“L'origine est (0.00, 0.00, 0.00)
UnityEngine.Debug:LogFormat (string,object[])”
Vous pouvez également fournir un second paramètre optionnel à ces méthodes de journalisation pour indiquer que le message est associé à un GameObject particulier :
Debug.LogWarning("Je viens en paix !", this.gameObject);
Lorsque vous affichez des données de variable formatées, il existe des versions d'avertissement et d'erreur de Debug.LogFormat :
Si vous envoyez une valeur float à la Console en utilisant Debug.Logformat, l'affichage par défaut montrera six chiffres après le point décimal. Vous pouvez contrôler ce comportement avec une chaîne de formatage numérique personnalisée.
Debug.LogFormat("pi = {0:0.00}", Mathf.PI);
En utilisant un deux-points, la chaîne de formatage 0.00 affichera la partie entière d'une valeur, le séparateur décimal et deux chiffres suivant le séparateur. Le dernier chiffre sera arrondi en fonction de la valeur suivante en utilisant la méthode familière 4 vers le bas, 5 vers le haut.
Dans cet exemple, la sortie serait : pi = 3.14
Comment exécuter des tests automatisés pour vos jeux avec le Unity Test Framework
Debug.Assert() est similaire à la méthode Debug.Log(), mais au lieu d'enregistrer un message dans la console, il teste une condition et affiche un message d'erreur si la condition est fausse. Il est utilisé pour valider des hypothèses et détecter des erreurs pendant le développement.
Les assertions sont un excellent moyen de vérifier que votre programme n'entre pas dans un état inattendu. Elles sont comme l'insertion d'un Log à l'intérieur d'une instruction if. Lorsque vous travaillez sur une méthode qui dépend d'une propriété de classe étant assignée, une assertion peut vous aider à traquer les erreurs.
Lorsque Debug.Assert() est appelé, il prend deux paramètres : une condition à tester et un message optionnel à afficher si la condition est fausse. Si la condition est vraie, rien ne se passe et le programme continue de s'exécuter. Si la condition est fausse, le programme cesse de s'exécuter et un message d'erreur est affiché dans l'Éditeur.
void SetColor(Color color)
{
Debug.Assert(material != null, "ChangeColor : matériel non assigné");
material.SetColor("_Color", color);
}
Si vous appelez SetColor et que le matériel n'est pas assigné, 'SetColor : matériel non assigné' sera affiché dans la Console.
Debug.Break() est une méthode fournie par la classe Debug de Unity qui est utilisée pour mettre en pause l'exécution de votre jeu et entrer dans le débogueur au point actuel de votre code. Cela vous permet d'inspecter l'état de votre jeu et de parcourir votre code ligne par ligne pour trouver et corriger des bogues.
Lorsque Debug.Break() est appelé, il interrompt l'exécution de votre jeu et ouvre la fenêtre du débogueur. Cela vous permet d'examiner l'état de votre jeu et de déboguer votre code si nécessaire. Vous pouvez utiliser le débogueur pour parcourir votre code, définir des points d'arrêt et inspecter des variables et des objets en mémoire.
Par exemple, vous pourriez vouloir arrêter un jeu lorsqu'un PNJ est à une distance cible du personnage joueur. Lorsque le jeu se bloque, vous pouvez examiner son état dans l'Inspecteur :
float dist = Vector3.Distance(transform.position, npc.position);
if ( dist < 5) Debug.Break();
Debug.DrawLine et Debug.DrawRay sont deux méthodes fournies par la classe Debug de Unity qui sont utilisées pour le débogage visuel. Elles sont utiles pour tester et visualiser le code lié à la physique, comme les collisions et les rayons. Les deux vous permettent de dessiner une ligne colorée qui est visible à la fois dans les vues Jeu et Scène. Par exemple, vous pouvez utiliser Debug.DrawRay pour visualiser la trajectoire d'une balle ou le chemin d'un faisceau laser et utiliser Debug.DrawLine pour visualiser les limites d'un collider ou le mouvement d'un objet.
Debug.DrawLine est utilisé pour dessiner une ligne droite entre deux points dans la scène :
Debug.DrawLine(transform.position, target.position, Color.white, 0, false);
Il prend de deux à cinq paramètres : un point de départ, un point d'arrivée et une couleur optionnelle. Par exemple, le code suivant dessinerait une ligne blanche entre les points start et end :
public static void DrawLine(Vector3 start, Vector3 end, Color color = Color.white, float duration = 0.0f, bool depthTest = true);
Paramètres
Dans l'exemple de code, la méthode Update d'un script MonoBehaviour attaché à l'objet de jeu Skeleton donne l'image vue ci-dessus. La ligne n'est visible dans la vue Jeu que si les gizmos sont activés. Cliquez sur le bouton Gizmo en haut à droite du panneau de vue Jeu pour les activer. La ligne est également visible dans la vue Scène.
L'alternative à DrawLine est DrawRay. Debug.DrawRay est utilisé pour dessiner un rayon dans la scène, partant d'une origine spécifiée et s'étendant dans une direction spécifiée. Par défaut, c'est un rayon infini. Lorsque le rayon dessiné par Debug.DrawRay() touche un collider, il s'arrêtera au point d'intersection et ne continuera pas plus loin. Ce comportement est le même que celui d'un raycast dans Unity, utilisé pour détecter les collisions entre des objets dans une scène.
Ici, le deuxième paramètre définit une direction et une longueur de la ligne. La ligne sera tracée de start à start + dir :
public static void DrawRay(Vector3 start, Vector3 dir, Color color = Color.white, float duration = 0.0f, bool depthTest = true);
Les paramètres dans l'exemple de code sont :
Voici un autre exemple de code :
Vector3 dir = transform.TransformDirection(Vector3.forward) * 3;Debug.DrawRay(transform.position, dir, Color.white, 0, false);
Dans cet exemple de code, la méthode Update d'un script MonoBehaviour attaché à l'objet de jeu Skeleton donne le résultat de l'image ci-dessus. Un rayon avec une longueur peut être utile pour déboguer des tests de proximité. Ici, la longueur du rayon est de 3 unités mondiales. Si une attaque doit commencer à 3 unités, alors vous avez un excellent test visuel de la longueur de 3 unités dans votre scène.
Conseils de test et d'assurance qualité pour les projets Unity
Les Gizmos sont un outil puissant pour le débogage visuel dans Unity. Ils vous permettent de dessiner des formes simples en 2D et 3D, des lignes et du texte dans la vue de la scène, ce qui facilite la visualisation et la compréhension de ce qui se passe dans votre monde de jeu.
Vous pouvez dessiner des formes simples et des lignes dans la vue de la scène avec juste quelques lignes de code. Cela en fait un outil idéal pour prototyper et tester rapidement vos mécaniques de jeu. Ils sont dessinés en temps réel, vous pouvez donc voir immédiatement les résultats de vos modifications de code et apporter les changements nécessaires.
Les Gizmos indiquent visuellement des mécaniques de jeu complexes qui pourraient être difficiles à comprendre uniquement par le code. Par exemple, vous pouvez utiliser des Gizmos pour dessiner une ligne montrant le chemin d'un projectile ou pour visualiser les limites d'une zone de déclenchement, comme le montre l'image ci-dessus.
Utilisez des gizmos pour créer des aides visuelles qui facilitent la compréhension de votre code et de vos mécaniques de jeu par les autres membres de l'équipe.
Les Gizmos ont peu d'impact sur les performances, vous pouvez donc les utiliser librement sans ralentir les performances.
L'icône gizmo se trouve dans le coin supérieur droit des vues Scene et Game. Pour ajouter un gizmo personnalisé, vous devez ajouter un script qui inclut un rappel OnDrawGizmos, comme le montre l'exemple de code ci-dessous. Ce script dessinera un cube filaire positionné à 3 unités du monde devant la position de l'objet de jeu. La taille du cube est définie par la propriété de classe vsize du type Vector3 : public Vector3 vsize = new Vector3(1f, 1f, 1f);
void OnDrawGizmos()
{
// Dessiner une sphère jaune à la position de la transformation
Gizmos.color = Color.yellow;
Vector3 position = transform.position + transform.TransformDirection(Vector3.forward) * 3;
Gizmos.DrawWireCube(position, vsize);
}
Contrôlez la visibilité en cliquant sur le menu déroulant des gizmos. Tous les scripts avec un rappel OnDrawGizmos seront listés.
Consultez documentation pour en savoir plus sur d'autres méthodes utiles avec la classe Gizmo.
Lancer une exception est une technique utilisée en programmation pour indiquer qu'une erreur ou une situation exceptionnelle s'est produite lors de l'exécution d'un programme. Vous pouvez utiliser cette méthode pour arrêter le fil d'exécution afin d'éviter d'autres dommages.
Dans Unity, lancer une exception est utilisé de la même manière que dans d'autres langages de programmation.
Si une exception est lancée et n'est pas interceptée et gérée dans le code, l'exécution du programme s'arrêtera généralement et vous serez expulsé de l'application et renvoyé au système d'exploitation. Dans Unity, l'exécution du programme est immédiatement arrêtée et l'environnement d'exécution recherche un bloc "catch" qui peut gérer l'exception. Si aucun bloc catch n'est trouvé, le programme se terminera et l'exception sera enregistrée dans la Console.
Lancer des exceptions peut être utile car cela vous permet de séparer la logique de gestion des erreurs du reste de votre logique de programme, ce qui peut contribuer à écrire un code plus propre. En lançant des exceptions, vous pouvez signaler à l'appelant qu'il y a eu un problème sans avoir à vous fier aux valeurs de retour ou à l'état global pour communiquer l'erreur.
Pour lancer une exception dans Unity, vous pouvez utiliser le mot-clé throw suivi d'un objet d'exception. Voici un exemple :
if (target == null)
{
throw new System.NullReferenceException("target not set!");
}
Lorsque vous exécutez votre code dans l'éditeur, il intercepte les erreurs lancées et effectue un Debug.LogError() au lieu de faire planter Unity ou l'application.
Utiliser des exceptions dans Unity vous permet d'attraper les erreurs tôt. Cela peut également faciliter le débogage en vous fournissant plus d'informations sur l'endroit où les erreurs se produisent et ce qui les a causées.
Apprenez beaucoup plus sur les tests, le débogage et l'amélioration des performances de votre projet Unity dans ces articles :
Plongez dans les meilleures pratiques avancées et les instructions pour les développeurs Unity avec ces e-books :
Trouvez de nombreuses ressources avancées dans le hub des meilleures pratiques de Unity.
