Si vous avez de l'expérience avec Unity, vous avez probablement utilisé la fenêtre Console pour afficher les erreurs, les avertissements et les autres messages générés par l'éditeur. Vous avez certainement aussi imprimé vos propres messages sur la console à l'aide de la classe Debug.

Mais vous n'êtes pas limité au seul message Debug.Log. Lorsque vous créez des chaînes de caractères dans la fenêtre de la console, vous pouvez spécifier l'un des trois types (erreur, avertissement et message), chacun ayant son propre type d'icône.

Les trois variantes sont les suivantes :

• Debug.Log ("Ceci est un message de journal.")
• Debug.LogWarning ("Ceci est un message d'avertissement.")
• Debug.LogError ("Ceci est un message d'erreur.")

Vous pouvez utiliser la fenêtre de la 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 de la console, puisque toutes les erreurs que vous écrivez dans la console via la classe Debug entraîneront la mise en pause du mode Play d'Unity.

Tout ce qui est affiché dans la fenêtre de la console, que ce soit par Unity ou par vos propres messages, est ajouté à un fichier journal que vous pouvez consulter pour savoir où les problèmes se sont produits dans votre application. Chaque système d'exploitation stocke les fichiers journaux à des endroits différents. Il convient donc de consulter la documentation pour connaître les spécifications de chaque système.

Lorsqu'une erreur ou une exception est déclenchée, la fenêtre de la console affiche la trace de la pile ainsi que le message d'erreur pour vous aider à comprendre comment l'erreur s'est produite et d'où elle provient. Debug.Log vous permet d'envoyer un message à la console, mais vous pouvez également configurer le niveau de détail affiché dans la trace de pile.

Par défaut, la sortie dans la console renvoie à 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 à l'origine de l'entrée.

Si le script ne s'ouvre pas dans l'IDE que vous avez choisi, allez dans Fichier > Préférences > Outils externes et sélectionnez l '"Editeur de script externe" dans la liste déroulante.

Vous pouvez configurer les informations affichées dans la trace de pile via Fichier > Paramètres de construction... > Paramètres du lecteur ... > Autres paramètres dans l'éditeur.

Les options suivantes sont disponibles pour chaque type de journal :

• Aucun: Aucune trace de pile ne sera affichée dans le journal.
• ScriptOnly: Seule la trace de la pile gérée sera affichée. Il s'agit de l'option par défaut si vous n'avez pas modifié les paramètres.
• Complet: Les traces de pile natives et gérées seront enregistrées.

Utilisez la fonction de recherche de la console si votre journal est encombré. Lorsque vous tapez un terme de recherche, la console filtre les messages pour n'afficher que ceux qui contiennent le texte correspondant.

Contrôlez le nombre de lignes de chaque entrée visible dans la liste en cliquant sur le bouton de menu 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.

Le format String.Format en C# vous permet de créer une chaîne de caractères avec des données variables formatées intégrées. La classe Debug possède Debug.LogFormatqui utilise la même syntaxe.

Le premier paramètre est la chaîne de messages formatée. En incluant une valeur d'index entre accolades, celle-ci sera remplacée par le paramètre index-1 en utilisant sa méthode ToString, si elle existe, ou la conversion de chaîne du système. Dans l'exemple de code ci-dessus, ligne 14, {0} sera remplacé par origin.ToString().

Voici un exemple plus complexe :

Debug.LogFormat("At Start 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 sera le suivant :

"L'origine est (0.00, 0.00, 0.00)

UnityEngine.Debug:LogFormat (string,object[])"

Vous pouvez également fournir un second paramètre facultatif à 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 variables formatées, il existe des versions d'avertissement et d'erreur de Debug.LogFormat :

• Debug.LogWarningFormat("La valeur de Cube.position.x est {0:0.00}", transform.position.x)
• Debug.LogErrorFormat("La valeur de Cube.position.x est {0:0.00}", transform.position.x)

Si vous envoyez une valeur flottante à la console en utilisant Debug.Logformat, l'affichage par défaut montrera six chiffres après la virgule. Vous pouvez contrôler ce comportement à l'aide d'une chaîne de formatage numérique personnalisée.

Debug.LogFormat("pi = {0:0.00}", Mathf.PI) ;

En utilisant les deux points, la chaîne de formatage 0.00 affichera la partie entière d'une valeur, le séparateur décimal et les deux chiffres qui suivent le séparateur. Le dernier chiffre sera arrondi sur la base de la valeur suivante selon la méthode familière : 4 au sol, 5 au ciel.

Dans cet exemple, le résultat 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, elle teste une condition et affiche un message d'erreur si la condition est fausse. Il est utilisé pour valider les hypothèses et détecter les erreurs au cours du développement.

Les assertions sont un excellent moyen de vérifier que votre programme n'entre pas dans un état inattendu. C'est comme si l'on intégrait un Log à l'intérieur d'une instruction if. Lorsque vous travaillez sur une méthode qui dépend de l'affectation d'une propriété de classe, une assertion peut vous aider à repérer les erreurs.

Lorsque Debug.Assert() est appelé, il prend deux paramètres : une condition à tester et un message facultatif à afficher si la condition est fausse. Si la condition est vraie, rien ne se passe et le programme continue à s'exécuter. Si la condition est fausse, le programme s'arrête et un message d'erreur s'affiche dans l'éditeur.

void SetColor(Couleur couleur)

{

Debug.Assert(material != null, "ChangeColor : material not assigned") ;

material.SetColor("_Color", color);

}

Si vous appelez SetColor et que le matériau n'est pas attribué, la mention "SetColor : matériau non attribué" s'affiche 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. Il vous permet d'inspecter l'état de votre jeu et de parcourir votre code ligne par ligne pour trouver et corriger les bogues.

L'appel de Debug.Break() interrompt l'exécution du 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 les variables et les objets en mémoire.

Par exemple, vous pourriez vouloir arrêter une partie lorsqu'un PNJ se trouve à distance de cible du personnage du joueur. Lorsque le jeu s'interrompt, vous pouvez examiner son état dans l'inspecteur :

float dist = Vector3.Distance(transform.position, npc.position) ;

si ( 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. Ils sont utiles pour tester et visualiser le code lié à la physique, tel que les collisions et les rayonnements. Les deux permettent de tracer une ligne de couleur visible à la fois dans la vue du jeu et dans celle de la scène. Par exemple, vous pouvez utiliser Debug.DrawRay pour visualiser la trajectoire d'une balle ou la trajectoire d'un rayon laser et utiliser Debug.DrawLine pour visualiser les limites d'un collisionneur ou le mouvement d'un objet.

Debug.DrawLine permet de tracer une ligne droite entre deux points de la scène :

Debug.DrawLine(transform.position, target.position, Color.white, 0, false) ;

Il prend deux à cinq paramètres : un point de départ, un point d'arrivée et une couleur facultative. Par exemple, le code suivant dessine une ligne blanche entre les points de départ et d'arrivée :

public static void DrawLine(Vector3 start, Vector3 end, Color color = Color.white, float duration = 0.0f, bool depthTest = true) ;

Paramètres

• commencer: Point dans l'espace mondial où la ligne doit commencer
• fin: Point dans l'espace mondial où la ligne doit se terminer
• couleur: La couleur de la ligne
• durée: Durée en secondes de l'affichage de la ligne. 0 affiche la ligne pour une seule trame
• depthTest: La ligne doit-elle être cachée par des objets de premier plan ?

Dans l'exemple de code, la méthode Update d'un script MonoBehaviour attaché au Skeleton GameObject donne l'image ci-dessus. La ligne n'est visible en mode jeu que si les gadgets sont activés. Cliquez sur le bouton Gizmo en haut à droite du panneau d'affichage du 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, il s'agit d'un rayon infini. Lorsque le rayon dessiné par Debug.DrawRay() heurte une collision, il s'arrête au point d'intersection et ne continue pas plus loin. Ce comportement est le même que celui d'un raycast dans Unity, utilisé pour détecter les collisions entre les objets d'une scène.

Ici, le deuxième paramètre définit la direction et la longueur de la ligne. La ligne sera tracée du début au début + dir :

public static void DrawRay(Vector3 start, Vector3 dir, Color color = Color.white, float duration = 0.0f, bool depthTest = true) ;

Les paramètres de l'exemple de code sont les suivants :

• commencer: Point dans l'espace mondial où la ligne doit commencer
• dir : Direction et longueur de la ligne dans l'espace mondial
• couleur: La couleur de la ligne
• durée: Temps en secondes pour afficher la ligne ; 0 affiche la ligne pour une seule trame
• depthTest: La ligne doit-elle être cachée par des objets de premier plan ?

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é au Skeleton GameObject donne l'image ci-dessus. Un rayon avec une longueur peut être utile pour déboguer les tests de proximité. Ici, la longueur du rayon est de 3 unités mondiales. Si une attaque doit commencer à 3 unités, vous disposez alors d'un excellent test visuel pour déterminer la durée de 3 unités dans votre scène.

Conseils en matière de tests et d'assurance qualité pour les projets Unity

Les gadgets 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 Scène, facilitant ainsi la visualisation et la compréhension de ce qui se passe dans votre univers de jeu.

Quelques lignes de code suffisent pour dessiner des formes et des lignes simples dans la vue Scène. Ils constituent donc un outil idéal pour prototyper et tester rapidement les mécanismes de votre jeu. Ils sont dessinés en temps réel, ce qui vous permet de voir immédiatement les résultats de vos modifications de code et d'apporter les changements nécessaires.

Les gadgets indiquent des mécanismes de jeu visuellement complexes qui pourraient être difficiles à comprendre par le seul biais du code. Par exemple, vous pouvez utiliser les Gizmos pour dessiner une ligne montrant la trajectoire d'un projectile ou pour visualiser les limites d'une zone de déclenchement, comme le montre l'image ci-dessus.

Utilisez des gadgets pour créer des aides visuelles qui permettent aux autres membres de l'équipe de comprendre plus facilement votre code et les mécanismes du jeu.

Les gadgets ont peu d'impact sur les performances, vous pouvez donc les utiliser librement sans les ralentir.

L'icône du gizmo se trouve dans le coin supérieur droit des vues Scène et Jeu. 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 dessine un cube filaire positionné à 3 unités du monde en avant de 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()

{

// Dessine 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 gadgets. Tous les scripts ayant un callback OnDrawGizmos seront listés.

Consultez la documentation pour en savoir plus sur les autres méthodes utiles de 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 pendant l'exécution d'un programme. Vous pouvez utiliser cette méthode pour arrêter l'exécution du fil 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 qu'elle n'est pas rattrapée et gérée dans le code, l'exécution du programme s'arrête généralement et vous êtes expulsé de l'application et renvoyé vers le système d'exploitation. Dans Unity, l'exécution du programme est immédiatement interrompue et l'environnement d'exécution recherche un bloc "catch" capable de gérer l'exception. Si aucun bloc de capture n'est trouvé, le programme se termine et l'exception est enregistrée dans la console.

Le fait de lancer des exceptions peut être utile car cela vous permet de séparer la logique de traitement des erreurs du reste de la logique de votre programme, ce qui peut contribuer à l'écriture d'un code plus propre. En lançant des exceptions, vous pouvez signaler à l'appelant que quelque chose n'a pas fonctionné 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 exception. Voici un exemple :

si (cible == null)

{

lancer une nouvelle exception System.NullReferenceException("target not set !") ;

}

Lorsque vous exécutez votre code dans l'éditeur, il attrape les erreurs lancées et fait un Debug.LogError() au lieu de faire planter Unity ou l'application.

L'utilisation d'exceptions dans Unity permet de détecter les erreurs à un stade précoce. Il peut également faciliter le débogage en vous fournissant davantage d'informations sur les erreurs et leurs causes.

Ces articles vous permettront d'en savoir plus sur les tests, le débogage et l'amélioration des performances de votre projet Unity :

• Comment déboguer le code d'un jeu avec les analyseurs Roslyn
• Comment exécuter des tests automatisés pour vos jeux avec le Unity Test Framework ?
• Accélérez votre flux de travail de débogage avec Microsoft Visual Studio Code
• Comment déboguer votre code avec Microsoft Visual Studio 2022
• Conseils en matière de tests et d'assurance qualité pour les projets Unity

Ces livres électroniques vous permettront de vous familiariser avec les meilleures pratiques et instructions pour les développeurs Unity :

• Guide essentiel pour le profilage des jeux Unity
• Optimisez les performances de votre jeu pour les mobiles
• Optimisez les performances de vos jeux sur console et PC

Vous trouverez de nombreuses ressources plus avancées dans le hub des meilleures pratiques Unity.