Errores de programación – Debug.Log en Unity

Por GameDevTraum

Introducción – Preparación del proyecto

En este artículo vamos a aprender a utilizar los mensajes en consola para analizar el funcionamiento de nuestro código y eventualmente detectar y corregir bugs.

Para empezar vamos a crear un proyecto nuevo en Unity, en mi caso lo voy a llamar Debugging.

Artículos de Introducción a la Programación

Fig. 1: Escena inicial para estudiar el método Debug.Log.

En el proceso de detección y corrección de bugs nos vamos a valer principalmente de la consola de Unity, en esa ventana se imprimirán mensajes que colocaremos estratégicamente en nuestro código.

Fig. 2: Pestaña consola en Unity 3D.

En caso de no tener activa la ventana de consola se puede abrir desde la pestaña Window como se observa en la figura 3.

Fig. 3: Ruta para abrir la consola en Unity 3D.

El siguiente paso es crear un nuevo Script C#, lo podemos hacer desde la ventana del proyecto como se observa en la figura 4. Voy a darle el nombre “Debugging”.

Clic aquí para saber más sobre Scripts en Programación

Fig. 4: Crear nuevo Script C#.
Fig. 5: El Script C# se llama Debugging.

Para que el código de nuestro Script se ejecute en general no basta con crear el Script, también tiene que estar asignado a al menos un GameObject de la jerarquía. Vamos a crear un Empty GameObject y le damos un nombre significativo.

Luego con ese GameObject seleccionado arrastramos el Script hacia el inspector para asignarlo (figura 8).

Fig. 6: Crear nuevo Empty GameObject en la jerarquía.
Fig. 7: Le damos un nombre al GameObject.
Fig. 8: Se asigna el Script creado anteriormente en el inspector.
Fig. 9: El Script Debugging ha sido asignado en el inspector.

Programación C# Unity – Debug.Log

Al abrir el Script (figura 10) vemos que hay algo de código que viene escrito por defecto. Se importan las librerías básicas y tenemos los métodos Start y Update los cuales se ejecutan automáticamente.

En mi canal hay un video sobre qué es un método en programación y también un artículo en esta página.

Fig. 10: Contenido por defecto de un Script C#.

Vamos a escribir una instrucción en el método Start. Esta instrucción es la ejecución del método Log de la clase Debug, al cual le pasaremos el mensaje que debe imprimir.

Como se observa en la figura 11, la instrucción es:

Debug.Log(“Este mensaje aparecerá en la consola”);

Fig. 11: Escribimos la instrucción Debug.Log en el método Start.

Entramos en el modo juego para probar el Script, para esto se utiliza el botón Play del Editor (figura 12).

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

Fig. 13: En la esquina inferior izquierda del programa también aparecen los mensajes de la consola.

Se observa que el mensaje aparece en la esquina inferior izquierda del programa sin que tengamos abierta la consola.

En la figura 14 separé la ventana de la consola para visualizar mejor la información.

Fig. 14: Mensaje en consola, a la derecha aparece un número que indica la cantidad de veces que se envía el mensaje.

Veamos qué ocurre si colocamos un mensaje en el método Update.

Fig. 15: Se coloca otro mensaje en el método Update.

A la derecha del mensaje se observa un número que indica la cantidad de veces que se imprime el mensaje.

Como se observa en la figura 16 el mensaje del método Update se ha impreso 82 al momento de la captura mientras que en la figura 17 el mensaje se ha impreso 350 veces.

Fig. 16: Captura de los mensajes en los primeros segundos del juego.
Fig. 17: Captura de los mensajes unos momentos después.

Utilización de variables

Los mensajes que queremos imprimir en consola puede estar almacenados en variables y el resultado es el mismo.

Fig. 18: Se definen dos strings con los mensajes y se colocan en los métodos.

Vamos a crear algunas variables más, un entero, un boolean y un float. Estos tres tipos de variables junto con los String son los tipos básicos de variables que vamos a utilizar en cualquier proyecto.

En el canal hay un video sobre qué es una variable en programación y también escribí un artículo para esta página.

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

Como se observa en la figura 19 vamos a declararlas e inicializarlas con un valor, esto lo podemos hacer en distintos puntos del Script, pero lo haremos en el inicio de la clase, antes del método Start.

Luego vamos a ejecutar tres métodos Debug.Log pasando como parámetro las variables.

Fig. 20: Se ejecuta Debug.Log con las nuevas variables.

Al entrar en el modo juego, en la consola aparecen los cuatro mensajes.

Fig. 21: En la consola se visualiza el valor de cada variable.

En versiones anteriores era necesario ejecutar el método ToString() para poder imprimir el valor de una variable que no sea un string, como se observa en la figura 22, esto se puede hacer pero ya no es necesario, se pueden pasar las varibles directamente.

Fig. 22: Ejecución de ToString() que convierte el valor de la variable en texto.

Vamos a definir 4 nuevas variables, una de cada tipo y darle valores distintos, como se ve en la figura 23.

Fig. 23: Se definen más variables para realizar operaciones.

Podemos hacer que en la consola se imprima el resultado de operaciones con variables, como se observa en la figura 24.

Si comparamos los valores de la figura 23 con las impresiones en consola que se ven en la figura 25, podemos verificar esto.

Fig. 24: En el parámetro de los métodos Debug.Log se ingresan operaciones.

Fig. 25: En la consola se imprimen los resultados de esas operaciones.

También es posible concatenar distintos tipos de variables e imprimir un mensaje.

Fig. 26: Se pueden concatenar distintos tipos de variable para formar el mensaje.
Fig. 27: Mensaje compuesto por distintos tipos de variables.

Contador de Frames

Previamente colocamos una instrucción Debug.Log en el método Update, la cual contenía un mensaje fijo.

Vamos a imprimir un mensaje que va a cambiar frame a frame.

Fig. 28: Se define un entero para contar la cantidad de frames que pasan.

Para empezar definimos un entero para contar los frames y lo inicializamos en el valor 0.

Vamos a concatenar el mensaje “Este es el frame: ” (incluyendo el espacio final), con el valor del contador.

Luego de mostrar el mensaje en consola, incrementamos el contador para que en el siguiente frame indique el número de frame siguiente.

Estas dos instrucciones se observan en la figura 29.

Fig. 29: Se imprime un mensaje con la cuenta de los frames y luego se incrementa el contador.

En las figuras 30 y 31 se observa la ejecución de este código en dos momentos distintos.

Fig. 30: Mensajes en los primeros segundos de ejecución.
Fig. 31: Mensajes que aparecen momentos después.

Elementos de un Array o vector de enteros

Ahora vamos a aplicar el Método Debug.Log para analizar los elementos de un Array.

Un Array es una estructura ordenada de datos de algún tipo sobre el cual se pueden hacer operaciones. Esta estructura de datos es como el vector matemático.

En primer lugar vamos a declarar un Array de enteros, esto es similar a declarar un número entero solo que añadiendo los corchetes luego del tipo, como se observa en la figura 32.

En ese mismo punto vamos a crear el Array con los valores que se ven en la figura 32.

Fig. 32: Se define un vector de enteros con distintos valores.

La lectura del Array la vamos a hacer en el método Start, en primer lugar vamos a escribir un mensaje que indique el tamaño del vector.

Para recorrer el Array utilizamos un bucle “for” que arranca desde 0 hasta la cantidad de elementos del Array menos uno.

Dentro del bucle for vamos a imprimir un mensaje en consola usando Debug.Log y concatenando texto con los valores de la variable.

bucle for en c# para detectar errores de programacion
Fig. 33: En el método Start vamos a analizar el array utilizando Debug.Log.

De esta forma utilizando la consola podemos estudiar el array y sus elementos, como se observa en la figura 34.

Fig. 34: Mensajes en consola que nos dan información sobre el Array.

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

Si tenemos un método que devuelve una variable, podemos aplicarlo como parámetro del método Debug.Log, como se observa en la figura 35.

Se define el método “UnMetodoExcelente” el cual devuelve un string.

La ejecución de este código se observa en la figura 36.

Fig. 35: Se define un método que devuelve un string para imprimir mensaje en consola.
Fig. 36: El mensaje consiste en el string que devuelve el método.

Lo mismo podríamos hacer con un método que requiera parámetros, como se ve en la figura 37.

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

Debug.Log para analizar el resultado de una sentencia if

El flujo de nuestro programa puede moverse por distintos caminos en función de los datos, por ejemplo en una sentencia if, el flujo del programa tomará uno de dos caminos posibles en función de la variable booleana que se evalúe.

En la figura 39 hacemos la definición de la sentencia if, la cual ejecutará un método o el otro. Cada método imprime su mensaje característico.

Fig. 39: Se definen dos métodos, uno de ellos será llamado aleatoriamente.

En las figuras 40 y 41 vemos la ejecución en dos momentos distintos del juego.

Fig. 40: En este caso se ejecutó el método CaminoDelMal.
Fig. 41: En este caso se ejecutó el método CaminoDelBien.

Conclusión

El método Debug.Log se utiliza para escribir mensajes en la consola.

Colocando estos mensajes estratégicamente en nuestro código somos capaces de visualizar el flujo del programa, obtener información del estado de nuestras variables y objetos.

El método Debug.Log toma como parámetro una variable que puede ser en principio string, bool, int o float, los tipos básicos de variables que hemos analizado en otros artículos.

Estos parámetros pueden ser entregados de distintas formas, por ejemplo es posible crear un mensaje concatenando variables, como el resultado de un método, ingresar las variables directamente o ingresar las operaciones cuyos resultados queremos que se impriman.