Dicas de teste e garantia de qualidade para projetos Unity

Os testes são cruciais para descobrir problemas como bugs no seu código, artefatos visuais na arte, ou problemas de experiência do usuário no design e jogabilidade do jogo. Você pode desenvolver o jogo mais tecnicamente impressionante, mas se ele travar nove vezes em cada dez, seus usuários vão desistir dele rapidamente.

Evite deixar os testes para o final do seu processo de desenvolvimento de jogos. Em vez de pensar nos testes como uma etapa em uma sequência, pode ser útil vê-los como um processo contínuo que fundamenta as outras etapas do desenvolvimento de jogos. Teste suas ideias e protótipos ao longo da produção e antes de lançar. Repita esse processo para cada atualização que você lançar para o seu jogo.

Existem uma variedade de técnicas de teste que podem se adequar melhor a diferentes etapas do seu projeto.

Você é membro de um pequeno estúdio sem uma equipe de QA dedicada? Reúna um grupo de amigos para ajudar com os testes ou escolha um fornecedor de QA terceirizado para ajudar. Mesmo estúdios com uma equipe de QA interna muitas vezes usarão uma empresa externa para serviços adicionais de teste, como teste de localização (LQA).

O teste com jogadores, que pode ser visto como um subconjunto de QA, ajuda a garantir que seu jogo ressoe com seu público-alvo e mercado. É um processo que pode fornecer feedback valioso dos jogadores para melhorar o jogo durante a fase de desenvolvimento.

As pessoas que devem participar do teste com jogadores variam dependendo dos objetivos específicos do teste. No entanto, em geral, é importante envolver um grupo diversificado de jogadores que represente o público-alvo do jogo. Ao envolver diferentes tipos de jogadores no teste com jogadores, os desenvolvedores de jogos podem coletar feedback de uma variedade de perspectivas e garantir que o jogo atraia um público amplo.

Nas seções seguintes, você pode ler sobre técnicas comuns de teste. Esses métodos podem ser combinados para garantir que sua base de código funcione da forma mais suave possível.

Também é importante testar o jogo em uma variedade de dispositivos dentro de suas plataformas-alvo. Isso se aplica especialmente a jogos móveis; você vai querer testar em diferentes sistemas operacionais, tamanhos de tela e nos dispositivos móveis de especificação mais baixa. Fazer isso ajudará a definir suas exigências mínimas de dispositivo, e cada categoria deve ser constantemente revisitada quando você adicionar mais recursos ao seu aplicativo.

Testar em várias plataformas não é apenas sobre identificar problemas que podem quebrar o jogo, também é importante entender implicações de longo prazo ou indiretas, como drenagem de bateria ou superaquecimento térmico para jogos móveis.

Os testes de unidade são uma técnica que envolve testar unidades ou componentes individuais de um jogo em isolamento, ajudando a garantir que os bugs sejam detectados cedo no processo de desenvolvimento e que as alterações no código não quebrem a funcionalidade existente.

Os testes de unidade são feitos escrevendo pequenos casos de teste que exercitam comportamentos específicos do código. Os testes podem ser executados em scripts individuais, GameObjects ou recursos específicos do jogo.

Métodos manuais e automatizados de teste de unidade devem ser usados no desenvolvimento de jogos.

Teste de unidade manual

O teste manual envolve pessoas jogando o jogo para testar seus recursos e funcionalidades. É importante realizar testes manuais porque existem problemas que os testes automatizados podem não detectar, como bugs de UI ou jogabilidade ou design desequilibrados ou mal executados.

Um exemplo de teste de unidade manual no Unity seria adicionar uma condição de teste para uma função e usar Debug.Log para exibir os critérios para ela passar ou falhar (a saída dos cenários de teste) usando o Modo de Jogo do Unity.

Teste de unidade automatizado

O teste de unidade automatizado requer escrever código para testar automaticamente unidades ou partes do código em isolamento. No Unity, você pode escrever testes para scripts, componentes e outras unidades de código do jogo que podem ser executados como parte de um conjunto de testes.

O pacote Unity Test Framework (UTF) fornece uma estrutura para os desenvolvedores escreverem seus próprios testes automatizados tanto em modos de Edição quanto de Jogo no Editor do Unity. O UTF procura um teste dentro de qualquer assembly que referencia NUnit. Esses assemblies são chamados de TestAssemblies. Os testes em modo de Jogo e em modo de Edição precisam estar em assemblies separados.

O UTF fornece uma janela Test Runner no Editor para ajudar você a executar e gerenciar seus casos de teste.

Como o UTF usa uma Definição de Assembly de Teste, você precisará dividir seu projeto em definições de assembly de tempo de execução. Isso é mais fácil de fazer quando você planeja isso cedo no processo de desenvolvimento; também incentiva você a escrever um código mais modular.

O pacote Unity, Performance Testing Extension é uma extensão que você pode usar com o UTF. Ele fornece APIs extras para fazer medições e fornecer métricas personalizadas a partir de seus casos de teste.

Aprenda como começar com o Unity Test Framework lendo o tutorial Unity Test Framework para desenvolvimento de jogos.

Desenvolvimento orientado a testes (TDD) é uma técnica que envolve escrever testes para uma funcionalidade antes de escrever o código real para implementá-la. O processo geralmente envolve escrever um teste que falha, escrever a quantidade mínima de código necessária para fazer o teste passar e, em seguida, refatorar o código para torná-lo mais manutenível antes de passar para o design do próximo caso de teste.

TDD é bastante raro no desenvolvimento de jogos (é mais comum no desenvolvimento de software convencional). Isso provavelmente se deve ao fato de ser um processo contra-intuitivo para prototipagem e criação de jogabilidade divertida e envolvente.

No entanto, pode acelerar o processo de identificação de partes quebradas dos seus jogos, porque quaisquer mudanças que quebrem o jogo criarão imediatamente casos de teste falhados.

Para mais sobre TDD no Unity, veja o post do blog “Testando o Desenvolvimento Orientado a Testes com o Unity Test Runner.”

Cobertura de código

Se você quiser implementar TDD ou testes unitários, considere usar o pacote Code Coverage do Unity. Quando usado com o UTF, o pacote Code Coverage pode mostrar quais linhas de código no seu projeto estão sendo testadas para ajudar a identificar partes vulneráveis ou não testadas do seu projeto.

Code Coverage também pode gerar relatórios enquanto você testa seu jogo no modo Play. Isso mostrará partes do seu código que você executa regularmente em testes, mesmo que não estejam cobertas por testes unitários. No entanto, enquanto os relatórios de Code Coverage mostram quais linhas de código foram cobertas no seu teste, não mostrarão diferentes caminhos que a lógica percorreu no código.

Veja o post do blog “Code Coverage: Identifique lacunas em seus testes” para mais informações.

Testes de integração são uma técnica que testa diferentes componentes de um sistema juntos para garantir que funcionem corretamente. Isso pode incluir testar como diferentes GameObjects, scripts ou sistemas interagem entre si dentro do jogo. Devido ao seu escopo mais amplo, os testes de integração podem ajudar a capturar bugs que podem não aparecer em testes unitários, como problemas com fluxo de dados ou comunicação entre componentes.

Por exemplo, em vez de usar testes unitários individuais, um teste de integração poderia ser escrito para toda essa sequência: um jogador disparando uma arma que instancia uma bala, a bala atingindo um inimigo e o matando, o jogador ganhando pontos por matar o inimigo e uma conquista sendo desbloqueada quando o jogador atinge uma certa pontuação.

Você pode usar o UTF para construir testes de integração no Unity. Usando os métodos SetUp e TearDown, você pode criar um ambiente para testar vários sistemas ao mesmo tempo. A lógica do jogador e a entrada podem ser simuladas, especialmente se você as implementou usando o Padrão de Comando (e se você estiver usando o novo Sistema de Entrada, então provavelmente você o fez), para que você possa testar o fluxo completo da entrada do jogador para a lógica do jogo.

Os testes de regressão são um método para verificar se o software ou recursos funcionam corretamente após serem modificados ou atualizados. O objetivo dos testes de regressão é garantir que as alterações no código não introduzam novos bugs ou regressões no software. Essa técnica é melhor aplicada a aplicações grandes e complexas com atualizações frequentes, como um jogo ao vivo, onde pode haver muitos componentes diferentes que podem interagir de maneiras inesperadas.

À medida que seu mundo de jogo e mecânicas se expandem, também aumenta a necessidade de testes de regressão, o que pode torná-los custosos. Portanto, é importante automatizá-los sempre que possível. Os testes de regressão devem ser realizados em paralelo com o desenvolvimento de novos recursos, especialmente se você estiver visando várias plataformas.

Embora os testes de regressão sejam mais adequados para jogos maiores e ao vivo, outros fatores, como a complexidade do software, a frequência de alterações ou atualizações e a importância crítica dos recursos afetados (sistemas críticos de missão ou segurança) também determinam sua necessidade.

Os testes funcionais avaliam a funcionalidade de um sistema ou aplicação de software testando-o em relação aos seus requisitos funcionais. Isso envolve testar os recursos do sistema, interfaces de usuário, interações com o banco de dados e outros aspectos que afetam seu comportamento e funcionalidade. O objetivo dos testes funcionais é verificar se o sistema ou aplicação atende aos requisitos e especificações fornecidos pelo cliente ou usuário final.

A maioria dos testes unitários foca em um caminho específico através do código, testando se ele retorna as saídas corretas com base em certas entradas. Não é capaz de testar se o jogo faz o que foi projetado para fazer.

Os testes funcionais são a abordagem para isso. Cada função ou recurso é comparado com o design original para ver se a saída atende às expectativas. Isso pode incluir testar os controles do jogo, mecânicas de jogo e a experiência geral do usuário.

Pode ser útil manter os testes funcionais em mente ao desenvolver seu jogo e criar tarefas com a abordagem "quando isso, então aquilo". Por exemplo, quando o jogador pressiona a barra de espaço, o personagem deve pular: Isso é tanto uma instrução para o desenvolvedor sobre como ele deve implementar um recurso, quanto um critério de aceitação para o testador testar. Às vezes, um recurso pode incluir alguns critérios de aceitação relacionados, como quando um recurso pode e não pode ser usado. Mas eles devem geralmente se concentrar em uma única peça de funcionalidade.

Os testes funcionais são mais poderosos quando os requisitos estão claramente definidos e delimitados. Assim, pode ser útil contratar freelancers ou estúdios para entregar componentes do seu gameplay ou ativos do mundo do jogo.

Você pode executar testes funcionais tanto automatizados quanto manuais. Tanto os testes de "caixa-preta" (testando o sistema sem conhecimento de seu funcionamento interno) quanto os testes de "caixa-branca" (testando o sistema com conhecimento de seu funcionamento interno) devem ser realizados.

Os testes de desempenho envolvem testar o jogo para garantir que ele funcione de forma suave e eficiente em diferentes configurações de hardware e software. Isso está intimamente relacionado a perfilamento e fluxos de trabalho gerais de otimização de desempenho, e essa prática pode ajudar a identificar gargalos de desempenho ou problemas que podem impactar o desempenho do jogo.

O objetivo principal é avaliar o desempenho de um sistema ou aplicação sob diferentes condições de carga de trabalho. No desenvolvimento de jogos, os testes de desempenho medem se o jogo funciona em um nível aceitável de desempenho, taxa de quadros, responsividade e estabilidade, e utiliza a memória de forma mais eficiente.

Diferentes tipos de testes de desempenho incluem:

• Testes de carga: Determina como o jogo se comporta quando submetido a cargas de trabalho pesadas
• Testes de estresse: Avalia como o jogo lida com situações inesperadas, como aumentos súbitos na atividade dos jogadores
• Testes de resistência: Avalia como o jogo se comporta ao longo de longos períodos de tempo

O Profiler do Unity

A ferramenta Profiler no Unity ajuda você a analisar o desempenho do seu jogo enquanto você o desenvolve. Funciona tanto no Editor, fornecendo uma visão geral enquanto você desenvolve, quanto em qualquer dispositivo conectado à sua máquina por cabo ou em uma rede local, fornecendo uma análise precisa de como seu jogo roda em um dispositivo alvo.

O Profiler pode ser estendido para personalizar a apresentação tanto do tipo de dados que você deseja capturar quanto de como será apresentado visualmente na janela do Profiler.

Saiba mais sobre como personalizar o Profiler na sessão Unite 2022 “Como personalizar métricas de desempenho no Profiler da Unity.”

Você também pode escrever suas próprias ferramentas para criar testes de desempenho automatizados. Para uma discussão interessante sobre como abordar isso, dê uma olhada na palestra dos desenvolvedores de Monument Valley, ustwo Games, da Unite 2022: “Fazendo Alba: Como construir um jogo de mundo aberto performático.”

Testes não se limitam a encontrar bugs e monitorar desempenho. Às vezes, você pode querer comparar duas versões de um recurso do jogo para determinar qual delas gera mais engajamento dos jogadores e tem um desempenho melhor. Isso é chamado de teste A/B.

O teste A/B é útil para modificar as estatísticas de um personagem ou armas que afetariam o equilíbrio do seu jogo, mas onde a mecânica do jogo permanece inalterada. Outros exemplos podem ser testes realizados para comparar a eficácia de diferentes tutoriais, mecânicas de jogo ou interfaces de usuário. Ao analisar os dados coletados dos dois grupos, você pode identificar qual versão do jogo ou recurso é mais eficaz e tomar decisões baseadas em dados sobre quais mudanças incorporar ao produto final.

O teste A/B envolve atribuir aleatoriamente os jogadores a dois grupos: Um grupo joga a versão original do jogo ou recurso (o grupo de controle), enquanto o outro grupo joga uma versão modificada do jogo ou recurso (o grupo experimental).

A chave é coletar dados sobre como uma pequena coorte de jogadores foi afetada pelas diferentes mudanças para ajudá-lo a tomar uma decisão de design sobre qual abordagem liberar como uma atualização ampla.

O teste A/B pode ajudar a melhorar a experiência do usuário e aumentar o engajamento e a retenção dos jogadores. É particularmente útil para jogos que têm grandes bases de usuários, onde até pequenas melhorias no engajamento ou retenção do usuário podem ter um impacto significativo.

O teste A/B é geralmente fornecido como um serviço de backend, com os jogadores nem mesmo cientes de que estão usando uma variante diferente. Os Serviços de Jogos Unity (UGS) têm ferramentas para ajudá-lo a executar testes A/B em seu jogo, sobre os quais você pode aprender mais aqui. Você também pode conferir os Casos de Uso do UGS, uma coleção de amostras para nossos serviços de backend, para explorar exemplos de como você pode configurar testes A/B em um jogo.

Cloud Diagnostics Advanced é uma ferramenta de relatórios e análise de falhas, alimentada pelo Backtrace, que se integra ao Unity para fornecer aos desenvolvedores informações detalhadas sobre falhas e exceções em seus jogos. Quando uma falha ocorre, o Cloud Diagnostics Advanced captura uma instantânea do estado do jogo no momento da falha, incluindo informações sobre o ambiente, pilha de chamadas, heap e registradores. Essa instantânea é então enviada para os servidores do Backtrace, onde é analisada para determinar a causa raiz da falha.

O Cloud Diagnostics Advanced também fornece análises detalhadas e ferramentas de relatórios, que podem ajudá-lo a identificar tendências e padrões no desempenho e estabilidade de seus jogos ao longo do tempo. Um algoritmo de deduplicação agrupa falhas comuns por sua causa raiz no código, que pode ser usado para ajudar a priorizar quais erros corrigir primeiro para melhorar a estabilidade para o maior número possível de jogadores.

Não importa quais técnicas de teste você use, é importante ter um plano em vigor sobre como você testará seu jogo e garantir que o teste seja uma parte integral do seu processo de desenvolvimento. Ao usar uma combinação dessas técnicas, você pode garantir que seu jogo Unity seja da mais alta qualidade e esteja pronto para produção.

Uma nova série de e-books para programadores está agora disponível gratuitamente pela Unity. Cada guia é escrito por programadores experientes e fornece melhores práticas para tópicos específicos que são importantes para as equipes de desenvolvimento.

Crie um guia de estilo C#: Escreva um código mais limpo que escale orienta as equipes a desenvolver um guia de estilo para ajudar a unificar sua abordagem para criar uma base de código mais coesa.

Eleve seu código com padrões de programação de jogos destaca as melhores práticas para usar os princípios SOLID e padrões de programação comuns para criar uma arquitetura de código de jogo escalável em seu projeto Unity.

Crie uma arquitetura de jogo modular no Unity com ScriptableObjects fornece melhores práticas para implantar ScriptableObjects na produção de jogos.

Criamos esta série para fornecer dicas acionáveis e inspiração para nossos criadores mais experientes. Mas eles não são livros de regras! Existem muitas maneiras de estruturar seu projeto Unity; avalie as vantagens e desvantagens de cada recomendação, dica e padrão com seus colegas antes de implantá-lo.

Encontre guias e artigos mais avançados no hub de melhores práticas da Unity.