Errores de programación — Debug.Log en Unity

Introducción — Preparación del proyecto

En este artícu­lo vamos a apren­der a uti­lizar los men­sajes en con­so­la para analizar el fun­cionamien­to de nue­stro códi­go y even­tual­mente detec­tar y cor­re­gir bugs.

Para empezar vamos a crear un proyec­to nue­vo en Uni­ty, en mi caso lo voy a lla­mar Debugging.

Fig. 1: Esce­na ini­cial para estu­di­ar el méto­do Debug.Log.

En el pro­ce­so de detec­ción y cor­rec­ción de bugs nos vamos a valer prin­ci­pal­mente de la con­so­la de Uni­ty, en esa ven­tana se imprim­irán men­sajes que colo­care­mos estratégi­ca­mente en nue­stro código.

Fig. 2: Pes­taña con­so­la en Uni­ty 3D.

En caso de no ten­er acti­va la ven­tana de con­so­la se puede abrir des­de la pes­taña Win­dow como se obser­va en la figu­ra 3.

Fig. 3: Ruta para abrir la con­so­la en Uni­ty 3D.

El sigu­iente paso es crear un nue­vo Script C#, lo podemos hac­er des­de la ven­tana del proyec­to como se obser­va en la figu­ra 4. Voy a dar­le el nom­bre "Debug­ging".

Clic aquí para saber más sobre Scripts en Pro­gra­mación

Fig. 4: Crear nue­vo Script C#.
Fig. 5: El Script C# se lla­ma Debugging.

Para que el códi­go de nue­stro Script se eje­cute en gen­er­al no bas­ta con crear el Script, tam­bién tiene que estar asig­na­do a al menos un GameOb­ject de la jer­ar­quía. Vamos a crear un Emp­ty GameOb­ject y le damos un nom­bre significativo.

Luego con ese GameOb­ject selec­ciona­do arras­tramos el Script hacia el inspec­tor para asig­narlo (figu­ra 8).

Fig. 6: Crear nue­vo Emp­ty GameOb­ject en la jerarquía.
Fig. 7: Le damos un nom­bre al GameObject.
Fig. 8: Se asigna el Script crea­do ante­ri­or­mente en el inspector.
Fig. 9: El Script Debug­ging ha sido asig­na­do en el inspector.

Programación C# Unity — Debug.Log

Al abrir el Script (figu­ra 10) vemos que hay algo de códi­go que viene escrito por defec­to. Se impor­tan las libr­erías bási­cas y ten­emos los méto­dos Start y Update los cuales se eje­cu­tan automáticamente.

En mi canal hay un video sobre qué es un méto­do en pro­gra­mación y tam­bién un artícu­lo en esta pági­na.

Fig. 10: Con­tenido por defec­to de un Script C#.

Vamos a escribir una instruc­ción en el méto­do Start. Esta instruc­ción es la eje­cu­ción del méto­do Log de la clase Debug, al cual le pasare­mos el men­saje que debe imprimir.

Como se obser­va en la figu­ra 11, la instruc­ción es:

Debug.Log("Este men­saje apare­cerá en la consola");

Fig. 11: Escribi­mos la instruc­ción Debug.Log en el méto­do Start.

Entramos en el modo juego para pro­bar el Script, para esto se uti­liza el botón Play del Edi­tor (figu­ra 12).

Fig. 12: Botón para entrar en el modo juego.

Fig. 13: En la esquina infe­ri­or izquier­da del pro­gra­ma tam­bién apare­cen los men­sajes de la consola.

Se obser­va que el men­saje aparece en la esquina infe­ri­or izquier­da del pro­gra­ma sin que teng­amos abier­ta la consola.

En la figu­ra 14 sep­a­ré la ven­tana de la con­so­la para visu­alizar mejor la información.

Fig. 14: Men­saje en con­so­la, a la derecha aparece un número que indi­ca la can­ti­dad de veces que se envía el mensaje.

Veamos qué ocurre si colo­camos un men­saje en el méto­do Update.

Fig. 15: Se colo­ca otro men­saje en el méto­do Update.

A la derecha del men­saje se obser­va un número que indi­ca la can­ti­dad de veces que se imprime el mensaje.

Como se obser­va en la figu­ra 16 el men­saje del méto­do Update se ha impre­so 82 al momen­to de la cap­tura mien­tras que en la figu­ra 17 el men­saje se ha impre­so 350 veces.

Fig. 16: Cap­tura de los men­sajes en los primeros segun­dos del juego.
Fig. 17: Cap­tura de los men­sajes unos momen­tos después.

Utilización de variables

Los men­sajes que quer­e­mos imprim­ir en con­so­la puede estar alma­ce­na­dos en vari­ables y el resul­ta­do es el mismo.

Fig. 18: Se definen dos strings con los men­sajes y se colo­can en los métodos.

Vamos a crear algu­nas vari­ables más, un entero, un boolean y un float. Estos tres tipos de vari­ables jun­to con los String son los tipos bási­cos de vari­ables que vamos a uti­lizar en cualquier proyecto.

En el canal hay un video sobre qué es una vari­able en pro­gra­mación y tam­bién escribí un artícu­lo para esta página.

Fig. 19: Se define una vari­able tipo entero, bool y float, cada una con valores.

Como se obser­va en la figu­ra 19 vamos a declarar­las e ini­cializarlas con un val­or, esto lo podemos hac­er en dis­tin­tos pun­tos del Script, pero lo hare­mos en el ini­cio de la clase, antes del méto­do Start.

Luego vamos a eje­cu­tar tres méto­dos Debug.Log pasan­do como parámetro las variables.

Fig. 20: Se eje­cu­ta Debug.Log con las nuevas variables.

Al entrar en el modo juego, en la con­so­la apare­cen los cua­tro mensajes.

Fig. 21: En la con­so­la se visu­al­iza el val­or de cada variable.

En ver­siones ante­ri­ores era nece­sario eje­cu­tar el méto­do ToString() para poder imprim­ir el val­or de una vari­able que no sea un string, como se obser­va en la figu­ra 22, esto se puede hac­er pero ya no es nece­sario, se pueden pasar las vari­bles directamente.

Fig. 22: Eje­cu­ción de ToString() que con­vierte el val­or de la vari­able en texto.

Vamos a definir 4 nuevas vari­ables, una de cada tipo y dar­le val­ores dis­tin­tos, como se ve en la figu­ra 23.

Fig. 23: Se definen más vari­ables para realizar opera­ciones.

Podemos hac­er que en la con­so­la se impri­ma el resul­ta­do de opera­ciones con vari­ables, como se obser­va en la figu­ra 24.

Si com­para­mos los val­ores de la figu­ra 23 con las impre­siones en con­so­la que se ven en la figu­ra 25, podemos ver­i­ficar esto.

Fig. 24: En el parámetro de los méto­dos Debug.Log se ingre­san operaciones.

Fig. 25: En la con­so­la se impri­men los resul­ta­dos de esas operaciones.

Tam­bién es posi­ble con­cate­nar dis­tin­tos tipos de vari­ables e imprim­ir un mensaje.

Fig. 26: Se pueden con­cate­nar dis­tin­tos tipos de vari­able para for­mar el mensaje.
Fig. 27: Men­saje com­puesto por dis­tin­tos tipos de variables.

Contador de Frames

Pre­vi­a­mente colo­camos una instruc­ción Debug.Log en el méto­do Update, la cual con­tenía un men­saje fijo. 

Vamos a imprim­ir un men­saje que va a cam­biar frame a frame.

Fig. 28: Se define un entero para con­tar la can­ti­dad de frames que pasan.

Para empezar defin­i­mos un entero para con­tar los frames y lo ini­cial­izamos en el val­or 0.

Vamos a con­cate­nar el men­saje "Este es el frame: " (incluyen­do el espa­cio final), con el val­or del contador.

Luego de mostrar el men­saje en con­so­la, incre­men­ta­mos el con­ta­dor para que en el sigu­iente frame indique el número de frame siguiente. 

Estas dos instruc­ciones se obser­van en la figu­ra 29.

Fig. 29: Se imprime un men­saje con la cuen­ta de los frames y luego se incre­men­ta el contador.

En las fig­uras 30 y 31 se obser­va la eje­cu­ción de este códi­go en dos momen­tos distintos.

Fig. 30: Men­sajes en los primeros segun­dos de ejecución.
Fig. 31: Men­sajes que apare­cen momen­tos después.

Elementos de un Array o vector de enteros

Aho­ra vamos a aplicar el Méto­do Debug.Log para analizar los ele­men­tos de un Array.

Un Array es una estruc­tura orde­na­da de datos de algún tipo sobre el cual se pueden hac­er opera­ciones. Esta estruc­tura de datos es como el vec­tor matemático.

En primer lugar vamos a declarar un Array de enteros, esto es sim­i­lar a declarar un número entero solo que aña­di­en­do los corchetes luego del tipo, como se obser­va en la figu­ra 32.

En ese mis­mo pun­to vamos a crear el Array con los val­ores que se ven en la figu­ra 32.

Fig. 32: Se define un vec­tor de enteros con dis­tin­tos valores.

La lec­tura del Array la vamos a hac­er en el méto­do Start, en primer lugar vamos a escribir un men­saje que indique el tamaño del vector.

Para recor­rer el Array uti­lizamos un bucle "for" que arran­ca des­de 0 has­ta la can­ti­dad de ele­men­tos del Array menos uno.

Den­tro del bucle for vamos a imprim­ir un men­saje en con­so­la usan­do Debug.Log y con­ca­te­nan­do tex­to con los val­ores de la variable.

bucle for en c# para detectar errores de programacion
Fig. 33: En el méto­do Start vamos a analizar el array uti­lizan­do Debug.Log.

De esta for­ma uti­lizan­do la con­so­la podemos estu­di­ar el array y sus ele­men­tos, como se obser­va en la figu­ra 34.

Fig. 34: Men­sajes en con­so­la que nos dan infor­ma­ción sobre el Array.

Imprimir el resultado de la ejecución de un Método

Si ten­emos un méto­do que devuelve una vari­able, podemos apli­car­lo como parámetro del méto­do Debug.Log, como se obser­va en la figu­ra 35.

Se define el méto­do "UnMeto­doEx­ce­lente" el cual devuelve un string.

La eje­cu­ción de este códi­go se obser­va en la figu­ra 36.

Fig. 35: Se define un méto­do que devuelve un string para imprim­ir men­saje en consola.
Fig. 36: El men­saje con­siste en el string que devuelve el método.

Lo mis­mo podríamos hac­er con un méto­do que requiera parámet­ros, como se ve en la figu­ra 37.

Fig. 37: Se añade un parámetro en el método.
Fig. 38: El men­saje depende del parámetro que le demos al método.

Debug.Log para analizar el resultado de una sentencia if

El flu­jo de nue­stro pro­gra­ma puede moverse por dis­tin­tos caminos en fun­ción de los datos, por ejem­p­lo en una sen­ten­cia if, el flu­jo del pro­gra­ma tomará uno de dos caminos posi­bles en fun­ción de la vari­able booleana que se evalúe. 

En la figu­ra 39 hace­mos la defini­ción de la sen­ten­cia if, la cual eje­cu­tará un méto­do o el otro. Cada méto­do imprime su men­saje característico.

Fig. 39: Se definen dos méto­dos, uno de ellos será lla­ma­do aleatoriamente.

En las fig­uras 40 y 41 vemos la eje­cu­ción en dos momen­tos dis­tin­tos del juego.

Fig. 40: En este caso se eje­cutó el méto­do CaminoDelMal.
Fig. 41: En este caso se eje­cutó el méto­do Camin­oDel­Bi­en.

Conclusión

El méto­do Debug.Log se uti­liza para escribir men­sajes en la consola.

Colo­can­do estos men­sajes estratégi­ca­mente en nue­stro códi­go somos capaces de visu­alizar el flu­jo del pro­gra­ma, obten­er infor­ma­ción del esta­do de nues­tras vari­ables y objetos.

El méto­do Debug.Log toma como parámetro una vari­able que puede ser en prin­ci­pio string, bool, int o float, los tipos bási­cos de vari­ables que hemos anal­iza­do en otros artículos.

Estos parámet­ros pueden ser entre­ga­dos de dis­tin­tas for­mas, por ejem­p­lo es posi­ble crear un men­saje con­ca­te­nan­do vari­ables, como el resul­ta­do de un méto­do, ingre­sar las vari­ables direc­ta­mente o ingre­sar las opera­ciones cuyos resul­ta­dos quer­e­mos que se impriman.

YouTube
Scroll al inicio
Secured By miniOrange