Sigue leyendo para aprender a mejorar tu calidad y tu proceso de depuración con la clase Debug de Unity.
Si bien es posible que ya estés familiarizado con la función Debug.Log, la clase Unity Debug admite muchas otras funciones útiles que pueden ayudarte a acelerar las pruebas y la depuración. Esta página explica cómo usar la clase Debug para la visualización de gizmos en las vistas de escena y juego, para pausar el modo Play en el Editor desde el script y más consejos.
Si tienes experiencia con Unity, probablemente usaste la ventana de consola para mostrar los errores, las advertencias y otros mensajes generados por el Editor. También imprimiste tus propios mensajes en la consola con la clase Debug.
Pero no te limitas solo al mensaje Debug.Log. Si creas cadenas de salida en la ventana de la consola, puedes especificar uno de tres tipos (error, advertencia y mensaje), cada uno con su propio tipo de ícono.
Las tres variantes son:
Puedes usar la ventana Consola para filtrar los mensajes según tus preferencias. También puedes aprovechar la opción Error Pause (pausa de error) habilitada en la ventana Console, ya que cualquier error que escribas en la consola a través de la clase Debug hará que el modo Play de Unity se detenga.
Todo lo que se envía a la ventana de la consola, ya sea por Unity o tus propios mensajes, se agrega a un archivo de registro al que puedes hacer referencia para ver dónde ocurrieron los problemas en tu aplicación. Cada sistema operativo almacena los archivos de registro en diferentes ubicaciones, por lo que consulta la documentación para ver las especificaciones de cada sistema.
Cuando se lanza un error o una excepción, la ventana de la consola muestra el rastro de la pila junto con el mensaje de error para ayudarte a entender cómo ocurrió el error y dónde se originó. Si bien Debug.Log te permite enviar un mensaje a la consola, también puedes configurar el nivel de detalle que se muestra en el stack trace.
De forma predeterminada, la salida de la consola se vincula con la línea de código que generó el mensaje, lo que permite identificar fácilmente la línea, el método o la secuencia de llamadas a la función que provocaron la aparición de la entrada.
Si el script no se abre en el IDE elegido, ve a Archivo > Preferencias > Herramientas externasy selecciona el «Editor de scripts externo» en el menú desplegable.
Puedes configurar la información que se muestra en el stack trace a través de File > Build Settings... > Player Settings ... > Other Settings in the Editor.
Hay disponibles las siguientes opciones para cada tipo de registro:
Utiliza la función de búsqueda en la consola si tu registro se aglomera. Al escribir un término de búsqueda, la consola filtra los mensajes para mostrar solo aquellos que contienen texto coincidente.
Para controlar cuántas líneas de cada entrada son visibles en la lista, haz clic en el botón del menú de la consola y selecciona Log Entry > [X] Lines en el menú, donde [X] es la cantidad de líneas que se mostrarán para cada entrada.
El método String.Format en C# te permite crear una cadena con datos variables con formato integrado. La clase Debug tiene Debug.LogFormat, que usa la misma sintaxis.
El primer parámetro es la cadena de mensajes con formato. Al incluir un valor de índice en los corchetes, este se reemplazará por el parámetro index-1 utilizando su método ToString, si existe, o la conversión de cadenas del sistema. En el ejemplo de código anterior, la línea 14, {0}, se reemplazará por origin.ToString().
Un ejemplo más complejo es el siguiente:
Debug.LogFormat("Al inicio transform.position={0}, transform.rotation={1}", transform.position, transform.rotation);
{0} se reemplazará por el parámetro 1, transform.position y {1} se reemplazará por el parámetro 2, transform.rotation. En cada caso se utilizará el método ToString de las propiedades Vector3 y Quaternion. El resultado será el siguiente:
«El origen es (0.00, 0.00, 0.00)
UnityEngine.Debug:LogFormat (string,object[])”
También puedes proporcionar un segundo parámetro opcional a estos métodos de registro para indicar que el mensaje está asociado con un GameObject en particular:
Debug.LogWarning("¡Vengo en paz!", this.gameObject);
Cuando muestra datos de variables con formato, existen versiones de advertencia y error de Debug.LogFormat:
Si envías un float value a la consola con Debug.Logformat, la pantalla predeterminada mostrará seis números después del punto decimal. Puedes controlar este comportamiento con una cadena de formato numérico personalizada.
Debug.LogFormat("pi = {0:0.00}", Mathf.PI);
Al usar un punto, la cadena de formato 0.00 mostrará la parte entera de un valor, el separador decimal y dos números después del separador. El último número se redondeará en función del siguiente valor utilizando el método conocido 4 al suelo, 5 al cielo.
En este ejemplo, el resultado sería: pi = 3.14
Cómo ejecutar pruebas automatizadas para tus juegos con Unity Test Framework
Debug.Assert() es similar al método Debug.Log(), pero en lugar de registrar un mensaje en la consola, prueba una condición y muestra un mensaje de error si la condición es falsa. Se utiliza para validar suposiciones y detectar errores durante el desarrollo.
Las afirmaciones son una excelente manera de verificar que tu programa no entre en un estado inesperado. Son como insertar un registro dentro de una sentencia condicional. Cuando estás trabajando en un método que se basa en la asignación de una propiedad de clase, una aserción puede ayudarte a rastrear los errores.
Cuando se llama a Debug.Assert(), se necesitan dos parámetros: una condición para hacer la prueba y un mensaje opcional para mostrar si la condición es falsa. Si la condición es cierta, no sucede nada y el programa continúa ejecutándose. Si la condición es falsa, el programa deja de ejecutarse y se muestra un mensaje de error en el Editor.
void SetColor(color del color)
{
Debug.Assert(material != null, "ChangeColor: material not assign");
material.SetColor("_Color", color);
}
Si llamas a SetColor y el material no está asignado, se mostrará "SetColor: material no asignado" en la consola.
Debug.Break() es un método proporcionado por la clase Debug de Unity que se utiliza para pausar la ejecución de tu juego e introducir el depurador en el punto actual de tu código. Te permite inspeccionar el estado de tu juego y revisar tu código línea por línea para encontrar y corregir errores.
Cuando se llama a Debug.Break(), se detiene la ejecución de tu juego y se abre la ventana Debugger. Esto te permite examinar el estado de tu juego y depurar tu código según sea necesario. Puedes usar el depurador para revisar tu código, establecer puntos de salida e inspeccionar variables y objetos en la memoria.
Por ejemplo, es posible que desees detener un juego cuando un NPC esté a una distancia objetivo del personaje del jugador. Cuando el juego se rompe, puedes examinar su estado en el Inspector:
float dist = Vector3.Distance(transform.position, npc.position);
if ( dist < 5) Debug.Break();
Debug.DrawLine y Debug.DrawRay son dos métodos proporcionados por la clase Debug de Unity que se utilizan para la depuración visual. Son útiles para probar y visualizar código relacionado con la física, como colisiones y Raycasts. Ambas te permiten dibujar una línea de color que sea visible tanto en la vista de Juego como en la de Escena. Por ejemplo, puedes usar Debug.DrawRay para visualizar la trayectoria de una bala o la trayectoria de un rayo láser y usar Debug.DrawLine para visualizar los límites de un collider o el movimiento de un objeto.
Debug.DrawLine se utiliza para dibujar una línea recta entre dos puntos de la escena:
Debug.DrawLine(transform.position, target.position, Color.white, 0, false);
Toma entre dos y cinco parámetros: un punto inicial, un punto final y un color opcional. Por ejemplo, el siguiente código dibujaría una línea blanca entre los puntos inicial y final:
public static void DrawLine(Vector3 start, Vector3 end, Color color = Color.white, float duration = 0.0f, bool depthTest = true);
Parámetros
En el ejemplo de código, el método Update de un script MonoBehaviour adjunto al GameObject Skeleton da como resultado la imagen que se ve arriba. La línea solo es visible en la vista de Juego si los gizmos están habilitados. Haz clic en el botón Gizmo en la esquina superior derecha del panel de vista de Juego para activarlos. La línea también es visible en la vista de escena.
La alternativa a DrawLine es DrawRay. Debug.DrawRay se utiliza para dibujar un rayo en la escena, a partir de un origen especificado y extendiéndose en una dirección especificada. De forma predeterminada, es un rayo infinito. Cuando el rayo dibujado por Debug.DrawRay() entra en contacto con un Collider, este se detiene en el punto de intersección y deja de existir. Este comportamiento es el mismo que el de un Raycast en Unity, utilizado para detectar colisiones entre objetos en una escena.
Aquí, el segundo parámetro define una dirección y una longitud de la línea. La línea se dibujará de principio a principio + dir:
public static void DrawRay(Vector3 start, Vector3 dir, Color color = Color.white, float duration = 0.0f, bool depthTest = true);
Los parámetros del ejemplo de código son los siguientes:
Este es otro ejemplo de código:
Vector3 dir = transform.TransformDirection(Vector3.forward) * 3;Debug.DrawRay(transform.position, dir, Color.white, 0, false);
En este ejemplo de código, el método Update de un script MonoBehaviour adjunto al GameObject Skeleton muestra la imagen de arriba. Un rayo con una longitud puede ser útil para depurar pruebas de proximidad. Aquí, la longitud del rayo es de 3 unidades de mundo. Si un ataque debe comenzar en 3 unidades, entonces tendrás una gran prueba visual de cuánto duran 3 unidades en tu escena.
Pruebas y consejos de control de calidad para proyectos Unity
Los gizmos son una poderosa herramienta para la depuración visual en Unity. Te permiten dibujar formas, líneas y texto 2D y 3D simples en la vista de escena, lo que te permite ver y entender fácilmente lo que está sucediendo en el mundo de tu juego.
Puedes dibujar formas y líneas simples en la vista de escena con solo unas líneas de código. Esto las convierte en una herramienta ideal para prototipar y probar rápidamente la mecánica de tu juego. Se dibujan en tiempo real, por lo que puedes ver los resultados de tus cambios de código de inmediato y hacer los cambios necesarios.
Los gizmos indican mecánicas de juego visualmente complejas que podrían ser difíciles de entender solo a través del código. Por ejemplo, puedes usar Gizmos para dibujar una línea que muestre la trayectoria de un proyectil o para visualizar los límites de una zona de activación, como se ve en la imagen de arriba.
Utiliza gizmos para crear ayudas visuales que faciliten a otros miembros del equipo la comprensión de tu código y la mecánica de tu juego.
Los gizmos tienen poco impacto en el rendimiento, por lo que puedes usarlos libremente sin ralentizar el rendimiento.
El ícono del gizmo se encuentra en la esquina superior derecha de las vistas Escena y Juego. Para agregar un gizmo personalizado, debes agregar un script que incluya una rellamada a OnDrawGizmos, como se muestra en el siguiente ejemplo de código. Este script dibujará un cubo de wireframe colocado 3 unidades de mundo hacia adelante de la posición del GameObject. El tamaño del cubo se define por el tamaño de la propiedad de la clase del tipo Vector3: public Vector3 vsize = new Vector3(1f, 1f, 1f);
void OnDrawGizmos()
{
// Dibujar una esfera amarilla en la posición del transform
Gizmos.color = Color.yellow;
Vector3 position = transform.position + transform.TransformDirection(Vector3.forward) * 3;
Gizmos.DrawWireCube(position, vsize);
}
Controla la visibilidad haciendo clic en el menú desplegable Gizmos. Se mostrarán todos los scripts con rellamada de OnDrawGizmos.
Revisa la documentación para obtener más información sobre otros métodos útiles con la clase de Gizmo.
Lanzar una excepción es una técnica utilizada en programación para indicar que se ha producido un error o una situación excepcional durante la ejecución de un programa. Puedes usar este método para evitar que el subproceso se siga ejecutando y evitar daños adicionales.
En Unity, lanzar una excepción se usa de la misma manera que en otros lenguajes de programación.
Si se lanza una excepción y el código no la captura ni la administra, la ejecución del programa se detendrá y, por lo general, se te expulsará de la aplicación y regresarás al sistema operativo. En Unity, la ejecución del programa se detiene inmediatamente y el entorno de tiempo de ejecución busca un bloque de "captura" que pueda manejar la excepción. Si no se encuentra ningún bloqueo de captura, el programa terminará y la excepción se registrará en la consola.
Lanzar excepciones puede ser útil, ya que esto te permite separar la lógica de manejo de errores del resto de la lógica de tu programa, lo que puede contribuir a escribir código más limpio. Al hacer excepciones, puedes indicarle a la persona que llama que algo salió mal sin tener que depender de los valores devueltos o el estado global para comunicar el error.
Para lanzar una excepción en Unity, puedes usar la palabra clave lanzamiento seguida de un objeto de excepción. Este es un ejemplo:
if (target == null)
{
lanzar un nuevo System.NullReferenceException("target not set!");
}
Cuando ejecutas tu código en el Editor, detecta los errores que se producen y hace un Debug.LogError() en lugar de bloquear Unity o la aplicación.
Usar excepciones en Unity te permite detectar los errores en las primeras etapas. También puede facilitar la depuración, ya que te brinda más información sobre dónde ocurren los errores y qué los causó.
Obtén mucho más información sobre las pruebas, la depuración y la mejora del rendimiento de tu proyecto Unity en estos artículos:
Descubre las prácticas recomendadas e instrucciones avanzadas para desarrolladores Unity con estos libros electrónicos:
Encuentra muchos más recursos avanzados en el centro de prácticas recomendadas de Unity.
