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ê certamente também imprimiu suas próprias mensagens no Console usando a classe Debug .

Mas você não está limitado apenas à mensagem Debug.Log. Ao criar strings de saída para a janela Console, você 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:

• Debug.Log (“Esta é uma mensagem de log.”)
• Debug.LogWarning (“Esta é uma mensagem de aviso.”)
• Debug.LogError (“Esta é uma mensagem de erro.”)

Você pode usar a janela Console para filtrar as mensagens com base em suas preferências. Você também pode aproveitar a vantagem de ter a Pausa de Erro habilitada na janela do Console, já que qualquer erro que você escrever no Console por meio da classe Debug fará com que o modo Play do Unity seja pausado.

Tudo o que é enviado para a janela do Console, seja pelo Unity ou por suas próprias mensagens, é adicionado a um arquivo de log que você pode consultar para ver onde os problemas ocorreram no seu aplicativo. Cada sistema operacional armazena os arquivos de log em locais diferentes, portanto, verifique a documentação para ver as especificações de cada sistema.

Quando um erro ou exceção é gerado, a janela Console exibe o rastreamento de pilha junto com a mensagem de erro para ajudar você a entender como o erro ocorreu e onde ele se originou. Embora Debug.Log permita que você envie uma mensagem para o Console, você também pode configurar o nível de detalhes mostrado no rastreamento de pilha.

Por padrão, a saída no Console vincula-se à 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 fizeram com que a entrada aparecesse.

Se o script não abrir no IDE escolhido, vá em Arquivo > Preferências > Ferramentas externas e selecione “Editor de script externo” no menu suspenso.

Você pode configurar as informações mostradas no rastreamento de pilha em Arquivo > Configurações de compilação… > Configurações do player… > Outras configurações no Editor.

As seguintes opções estão disponíveis para cada tipo de log:

• Nenhum: Nenhum rastreamento de pilha será enviado ao log.
• Somente script: Somente o rastreamento de pilha gerenciado será emitido. Esta é a opção padrão se você não alterou as configurações.
• Completo: O rastreamento de pilha nativo e gerenciado será registrado.

Utilize o recurso de pesquisa no Console caso seu log fique cheio. Conforme você digita um termo de pesquisa, 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 de menu Console e selecionando Entrada de Log > [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 variáveis formatados incorporados. A classe Debug tem Debug.LogFormat, que usa a mesma sintaxe.

O primeiro parâmetro é a sequência de mensagens formatada. Ao incluir um valor de índice entre chaves, ele será substituído pelo parâmetro index-1 usando seu método ToString , se existir, ou a conversão de string do sistema. 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 ficará assim:

“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);

Ao exibir dados variáveis formatados, há versões de aviso e erro do Debug.LogFormat:

• Debug.LogWarningFormat("O valor de Cube.position.x é {0:0.00}", transform.position.x)
• Debug.LogErrorFormat("O valor de Cube.position.x é {0:0.00}", transform.position.x)

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 sequência de formatação numérica personalizada.

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

Ao usar dois pontos, a sequência 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 conhecido: 4 para o chão, 5 para o céu.

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. Ele é usado para validar suposições e detectar erros durante o desenvolvimento.

Asserções são uma ótima maneira de verificar se seu programa não entra em um estado inesperado. Eles são como incorporar um Log dentro de uma instrução if. Quando você está trabalhando em um método que depende da atribuição de uma propriedade de classe, uma asserção pode ajudar a rastrear erros.

Quando Debug.Assert() é chamado, ele recebe dois parâmetros: uma condição para testar e uma mensagem opcional para exibir 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(Cor cor)

{

Debug.Assert(material != null, "ChangeColor: material não atribuído");

material.SetColor("_Color", color);

}

Se você chamar SetColor e o material não for 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 analise o 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 do alvo do personagem do jogador. Quando o jogo for interrompido, você pode examinar seu estado no Inspetor:

float dist = Vetor3. Distância(transformar.posição, npc.posição);

se ( 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ódigos relacionados à física, como colisões e raycasts. Ambos permitem que você desenhe uma linha colorida que fica visível nas visualizações de Jogo e Cena. Por exemplo, você pode usar Debug.DrawRay para visualizar a trajetória de uma bala ou o caminho de um raio 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);

São necessários de dois a cinco parâmetros: um ponto inicial, um ponto final e uma cor opcional. Por exemplo, o código a seguir desenharia uma linha branca entre os pontos inicial e final:

público estático vazio DrawLine(Vetor3 início, Vetor3 fim, Cor cor = Cor.branco, flutuação duração = 0,0f, bool profundidadeTeste = verdadeiro);

Parâmetros

• start: Ponto no espaço mundial onde a linha deve começar
• fim: Ponto no espaço mundial onde a linha deve terminar
• cor: A cor da linha
• duração: Tempo em segundos para exibir a linha. 0 exibe linha para quadro único
• Teste de profundidade: A linha deve ser escondida por objetos em primeiro plano

No exemplo de código, o método Update de um script MonoBehaviour anexado ao Skeleton GameObject resulta na imagem vista acima. A linha só fica visível na visualização do jogo se os dispositivos 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 de cena.

A alternativa ao DrawLine é o 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 intersecção e não continua mais. Esse comportamento é o mesmo de um raycast no Unity, usado para detectar colisões entre objetos em uma cena.

Aqui, o segundo parâmetro define a direção e o comprimento da linha. A linha será desenhada do início ao início + dir:

public static void DrawRay(Vector3 start, Vector3 dir, Cor cor = Color.white, float duração = 0.0f, bool depthTest = true);

Os parâmetros no exemplo de código são:

• start: Ponto no espaço mundial onde a linha deve começar
• dir: Direção e comprimento da linha no espaço mundial
• cor: A cor da linha
• duração: Tempo em segundos para exibir a linha; 0 exibe a linha para um único quadro
• Teste de profundidade: A linha deve ser escondida por objetos em primeiro plano

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 Skeleton GameObject resulta na imagem acima. Um raio com um comprimento pode ser útil para depurar testes de proximidade. Aqui, o comprimento do raio é de 3 unidades mundiais. Se um ataque começar com 3 unidades, você terá um ótimo teste visual de quanto tempo 3 unidades duram na sua cena.

Dicas de teste e garantia de qualidade para projetos Unity

Gizmos são uma ferramenta poderosa para depuração visual no Unity. Eles permitem que você desenhe formas, linhas e textos simples em 2D e 3D na visualização de Cena, facilitando a visualização e a compreensão do que está acontecendo no seu mundo de jogo.

Você pode desenhar formas e linhas simples na visualização de cena com apenas algumas linhas de código. Isso os torna uma ferramenta ideal para prototipar e testar rapidamente a mecânica do seu jogo. Eles são desenhados em tempo real, para que você possa ver os resultados das alterações no seu código imediatamente e fazer as alterações necessárias.

Gizmos indicam mecânicas de jogo visualmente complexas que podem ser difíceis de entender apenas por meio de código. Por exemplo, você pode usar o 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 dispositivos para criar recursos visuais que facilitem a compreensão do código e da mecânica do jogo por outros membros da equipe.

Os gadgets têm pouco impacto no desempenho, então você pode usá-los livremente sem prejudicar 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 retorno de chamada OnDrawGizmos, como mostra o exemplo de código abaixo. Este script desenhará um cubo de wireframe posicionado 3 unidades do mundo à frente da posição do GameObject. O tamanho do cubo é definido pela propriedade de 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;

Posição do vetor3 = transform.position + transform.TransformDirection(Vector3.forward) * 3;

Gizmos.DrawWireCube(position, vsize);

}

Controle a visibilidade clicando no menu suspenso de dispositivos. Todos os scripts com um retorno de chamada OnDrawGizmos serão listados.

Revise a documentação para saber 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 esse método para interromper a execução do thread e evitar maiores 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 for capturada e tratada no código, a execução do programa normalmente será interrompida e você será expulso do aplicativo e retornado ao sistema operacional. No Unity, a execução do programa é imediatamente interrompida e o ambiente de execução procura um bloco “catch” que possa manipular 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 permite separar a lógica de tratamento de erros do restante da lógica do 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 do 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:

se (alvo == nulo)

{

throw new System.NullReferenceException("destino não definido!");

}

Quando você executa seu código no Editor, ele captura os erros gerados e executa um Debug.LogError() em vez de travar o Unity ou o aplicativo.

Usar exceções no Unity permite que você detecte erros antecipadamente. Ele também pode facilitar a depuração, fornecendo mais informações sobre onde os erros ocorrem e o que os causou.

Aprenda muito mais sobre como testar, depurar e melhorar o desempenho do seu projeto Unity nestes artigos:

• Como depurar código de jogo com analisadores Roslyn
• Como executar testes automatizados para seus jogos com o Unity Test Framework
• Acelere seu fluxo de trabalho de depuração com o Microsoft Visual Studio Code
• Como depurar seu código com o Microsoft Visual Studio 2022
• Dicas de teste e garantia de qualidade para projetos Unity

Aprofunde-se nas melhores práticas e instruções avançadas para desenvolvedores Unity com estes e-books:

• Guia definitivo para a criação de perfis de jogos no Unity
• Otimize o desempenho do seu jogo para dispositivos móveis
• Otimize o desempenho dos seus jogos de console e PC

Encontre muitos outros recursos avançados no hub de melhores práticasdo Unity.