Continue lendo para aprender como melhorar seu processo de QA e depuração com a classe Debug do Unity.
Embora você já esteja familiarizado com a função Debug.Log, a classe Debug do Unity suporta muitas outras funções úteis que podem ajudá-lo a acelerar seus testes e depuração. Esta página explica como usar a classe Debug para visualização de gizmos nas visualizações de Cena e Jogo, pausar o modo Play no Editor a partir do script e mais dicas.
Se você tem experiência com o Unity, provavelmente já usou a janela Console para exibir erros, avisos e outras mensagens geradas pelo Editor. Você também certamente imprimiu suas próprias mensagens no Console usando a classe Debug.
Mas você não está limitado apenas à mensagem Debug.Log. Quando você cria strings de saída para a janela do Console, pode especificar um dos três tipos (erro, aviso e mensagem), cada um com seu próprio tipo de ícone.
As três variantes são:
Você pode usar a janela do Console para filtrar as mensagens com base em suas preferências. Você também pode aproveitar o recurso de Pausa de Erro ativado na janela do Console, já que quaisquer erros que você escrever no Console via a classe Debug farão com que o modo de reprodução do Unity pause.
Tudo que é enviado para a janela do Console, seja pelo Unity ou suas próprias mensagens, é adicionado a um Arquivo de Log que você pode consultar para ver onde os problemas ocorreram em seu aplicativo. Cada sistema operacional armazena os arquivos de log em locais diferentes, então verifique a documentação para ver as especificações de cada sistema.
Quando um erro ou exceção é lançado, a janela do Console exibe o rastreamento de pilha junto com a mensagem de erro para ajudá-lo a entender como o erro ocorreu e de onde ele se originou. Enquanto Debug.Log permite que você envie uma mensagem para o Console, você também pode configurar o nível de detalhe mostrado no rastreamento de pilha.
Por padrão, a saída no Console está vinculada à linha de código que gerou a mensagem, facilitando a identificação da linha, método ou sequência de chamadas de função que causaram a entrada a aparecer.
Se o script não abrir em seu IDE escolhido, vá para Arquivo > Preferências > Ferramentas Externas e selecione o “Editor de Script Externo” no menu suspenso.
Você pode configurar as informações mostradas no rastreamento de pilha via Arquivo > Configurações de Build… > Configurações do Player… > Outras Configurações no Editor.
As seguintes opções estão disponíveis para cada tipo de log:
Use o recurso de busca no Console se seu log ficar lotado. À medida que você digita um termo de busca, o Console filtra as mensagens para exibir apenas aquelas que contêm texto correspondente.
Controle quantas linhas de cada entrada são visíveis na lista clicando no botão do menu do Console e selecionando Log Entry > [X] Linhas no menu, onde [X] é o número de linhas a serem exibidas para cada entrada.
O método String.Format em C# permite que você crie uma string com dados de variável formatados incorporados. A classe Debug tem Debug.LogFormat, que usa a mesma sintaxe.
O primeiro parâmetro é a string da mensagem formatada. Ao incluir um valor de índice entre chaves, isso será substituído pelo índice do parâmetro menos 1 usando seu método ToString, se existir, ou a conversão de string do System. No exemplo de código acima, linha 14, {0} será substituído por origin.ToString().
Um exemplo mais complexo é este:
Debug.LogFormat("No Início transform.position={0}, transform.rotation={1}", transform.position, transform.rotation);
{0} será substituído pelo parâmetro 1, transform.position e {1} será substituído pelo parâmetro 2, transform.rotation. Em cada caso, o método ToString das propriedades Vector3 e Quaternion será usado. O resultado será parecido com isto:
“A origem é (0.00, 0.00, 0.00)
UnityEngine.Debug:LogFormat (string,object[])”
Você também pode fornecer um segundo parâmetro opcional para esses métodos de log para indicar que a mensagem está associada a um GameObject específico:
Debug.LogWarning("Eu venho em paz!", this.gameObject);
Quando você exibe dados de variável formatados, existem versões de aviso e erro de Debug.LogFormat:
Se você enviar um valor float para o Console usando Debug.Logformat, a exibição padrão mostrará seis números após o ponto decimal. Você pode controlar esse comportamento com uma string de formatação numérica personalizada.
Debug.LogFormat("pi = {0:0.00}", Mathf.PI);
Usando dois pontos, a string de formatação 0.00 exibirá a parte inteira de um valor, o separador decimal e dois números após o separador. O último número será arredondado com base no próximo valor usando o método familiar: 4 para baixo, 5 para cima.
Neste exemplo, a saída seria: pi = 3.14
Como executar testes automatizados para seus jogos com o Unity Test Framework
Debug.Assert() é semelhante ao método Debug.Log(), mas em vez de registrar uma mensagem no console, ele testa uma condição e exibe uma mensagem de erro se a condição for falsa. É usado para validar suposições e capturar erros durante o desenvolvimento.
Asserções são uma ótima maneira de verificar se seu programa não entra em um estado inesperado. Elas são como embutir um Log dentro de uma instrução if. Quando você está trabalhando em um método que depende de uma propriedade de classe ser atribuída, uma asserção pode ajudá-lo a rastrear erros.
Quando Debug.Assert() é chamado, ele recebe dois parâmetros: uma condição a ser testada e uma mensagem opcional a ser exibida se a condição for falsa. Se a condição for verdadeira, nada acontece e o programa continua a ser executado. Se a condição for falsa, o programa para de ser executado e uma mensagem de erro é exibida no Editor.
void SetColor(Color color)
{
Debug.Assert(material != null, "ChangeColor: material não atribuído");
material.SetColor("_Color", color);
}
Se você chamar SetColor e material não estiver atribuído, ‘SetColor: material não atribuído’ será exibido no Console.
Debug.Break() é um método fornecido pela classe Debug do Unity que é usado para pausar a execução do seu jogo e entrar no depurador no ponto atual do seu código. Ele permite que você inspecione o estado do seu jogo e percorra seu código linha por linha para encontrar e corrigir bugs.
Quando Debug.Break() é chamado, ele interrompe a execução do seu jogo e abre a janela do Depurador. Isso permite que você examine o estado do seu jogo e depure seu código conforme necessário. Você pode usar o depurador para percorrer seu código, definir pontos de interrupção e inspecionar variáveis e objetos na memória.
Por exemplo, você pode querer parar um jogo quando um NPC estiver dentro da distância alvo do personagem do jogador. Quando o jogo quebra, você pode examinar seu estado no Inspetor:
float dist = Vector3.Distance(transform.position, npc.position);
if ( dist < 5) Debug.Break();
Debug.DrawLine e Debug.DrawRay são dois métodos fornecidos pela classe Debug do Unity que são usados para depuração visual. Eles são úteis para testar e visualizar código relacionado à física, como colisões e raycasts. Ambos permitem que você desenhe uma linha colorida que é visível tanto na visualização do Jogo quanto na visualização da Cena. Por exemplo, você pode usar Debug.DrawRay para visualizar a trajetória de uma bala ou o caminho de um feixe de laser e usar Debug.DrawLine para visualizar os limites de um colisor ou o movimento de um objeto.
Debug.DrawLine é usado para desenhar uma linha reta entre dois pontos na cena:
Debug.DrawLine(transform.position, target.position, Color.white, 0, false);
Ele aceita de dois a cinco parâmetros: um ponto de partida, um ponto final e uma cor opcional. Por exemplo, o seguinte código desenharia uma linha branca entre os pontos start e end:
public static void DrawLine(Vector3 start, Vector3 end, Color color = Color.white, float duration = 0.0f, bool depthTest = true);
Parâmetros
No exemplo de código, o método Update de um script MonoBehaviour anexado ao GameObject Skeleton resulta na imagem vista acima. A linha só é visível na visualização do Jogo se os gizmos estiverem habilitados. Clique no botão Gizmo no canto superior direito do painel de visualização do Jogo para habilitá-los. A linha também é visível na visualização da Cena.
A alternativa a DrawLine é DrawRay. Debug.DrawRay é usado para desenhar um raio na cena, começando de uma origem especificada e se estendendo em uma direção especificada. Por padrão, é um raio infinito. Quando o raio desenhado por Debug.DrawRay() atinge um colisor, ele para no ponto de interseção e não continua mais. Esse comportamento é o mesmo que o de um raycast no Unity, usado para detectar colisões entre objetos em uma cena.
Aqui, o segundo parâmetro define uma direção e um comprimento da linha. A linha será desenhada de start para start + dir:
public static void DrawRay(Vector3 start, Vector3 dir, Color color = Color.white, float duration = 0.0f, bool depthTest = true);
Os parâmetros no exemplo de código são:
Aqui está outro exemplo de código:
Vector3 dir = transform.TransformDirection(Vector3.forward) * 3;Debug.DrawRay(transform.position, dir, Color.white, 0, false);
Neste exemplo de código, o método Update de um script MonoBehaviour anexado ao GameObject Skeleton resulta na imagem acima. Um raio com um comprimento pode ser útil para depurar testes de proximidade. Aqui, o comprimento do raio é 3 unidades do mundo. Se um ataque deve começar a 3 unidades, então você tem um ótimo teste visual de quão longo 3 unidades é na sua cena.
Gizmos são uma ferramenta poderosa para depuração visual no Unity. Eles permitem que você desenhe formas simples 2D e 3D, linhas e texto na visualização da Cena, facilitando a visualização e compreensão do que está acontecendo no seu mundo de jogo.
Você pode desenhar formas e linhas simples na visualização da Cena com apenas algumas linhas de código. Isso os torna uma ferramenta ideal para prototipagem rápida e teste de suas mecânicas de jogo. Eles são desenhados em tempo real, então você pode ver os resultados das mudanças no seu código imediatamente e fazer quaisquer alterações necessárias.
Gizmos indicam mecanicas de jogo visualmente complexas que podem ser difíceis de entender apenas através do código. Por exemplo, você pode usar Gizmos para desenhar uma linha mostrando o caminho de um projétil ou para visualizar os limites de uma zona de gatilho, como visto na imagem acima.
Use gizmos para criar auxílios visuais que facilitam para outros membros da equipe entenderem seu código e mecânicas de jogo.
Gizmos têm pouco impacto no desempenho, então você pode usá-los livremente sem desacelerar o desempenho.
O ícone do gizmo está no canto superior direito das visualizações de Cena e Jogo. Para adicionar um gizmo personalizado, você precisa adicionar um script que inclua um callback OnDrawGizmos, como o exemplo de código abaixo mostra. Este script desenhará um cubo de malha posicionado 3 unidades de mundo à frente da posição do GameObject. O tamanho do cubo é definido pela propriedade da classe vsize do tipo Vector3: public Vector3 vsize = new Vector3(1f, 1f, 1f);
void OnDrawGizmos()
{
// Desenhe uma esfera amarela na posição da transformação
Gizmos.color = Color.yellow;
Vector3 position = transform.position + transform.TransformDirection(Vector3.forward) * 3;
Gizmos.DrawWireCube(position, vsize);
}
Controle a visibilidade clicando no dropdown de gizmos. Qualquer script com um callback OnDrawGizmos será listado.
Revise documentação para aprender mais sobre outros métodos úteis com a classe Gizmo.
Lançar uma exceção é uma técnica usada em programação para indicar que um erro ou situação excepcional ocorreu durante a execução de um programa. Você pode usar este método para parar a thread de executar mais para evitar mais danos.
No Unity, lançar uma exceção é usado da mesma forma que em outras linguagens de programação.
Se uma exceção for lançada e não capturada e tratada no código, a execução do programa geralmente será interrompida e você será expulso do aplicativo e de volta ao sistema operacional. No Unity, a execução do programa é imediatamente interrompida e o ambiente de tempo de execução procura um bloco "catch" que possa lidar com a exceção. Se nenhum bloco catch for encontrado, o programa será encerrado e a exceção será registrada no Console.
Lançar exceções pode ser útil, pois isso permite separar a lógica de tratamento de erros do restante da lógica do seu programa, o que pode contribuir para escrever um código mais limpo. Ao lançar exceções, você pode sinalizar ao chamador que algo deu errado sem precisar depender de valores de retorno ou estado global para comunicar o erro.
Para lançar uma exceção no Unity, você pode usar a palavra-chave throw seguida de um objeto de exceção. Aqui está um exemplo:
if (target == null)
{
throw new System.NullReferenceException("target não definido!");
}
Quando você executa seu código no Editor, ele captura os erros lançados e faz um Debug.LogError() em vez de travar o Unity ou o aplicativo.
Usar exceções no Unity permite que você capture erros mais cedo. Isso também pode facilitar a depuração, fornecendo mais informações sobre onde os erros ocorrem e o que os causou.
Saiba muito mais sobre testes, depuração e melhoria do desempenho do seu projeto Unity nestes artigos:
Aprofunde-se em práticas recomendadas avançadas e instruções para desenvolvedores Unity com estes e-books:
Encontre muitos mais recursos avançados no hub de melhores práticas do Unity.
