Este guia descreve um ciclo típico de desenvolvimento de jogos. Depois de ler este guia, talvez seja útil usar também como referência.
Quando você trabalha com o Unity, o ciclo de vida de desenvolvimento consiste em três fases:
- Planejamento e design
- Desenvolver e testar
- Publicar e manter
Planejamento e design
Na fase de planejamento e design, você determina como criar seu jogo. Você decide como enfrentar os desafios do desenvolvimento em dispositivos móveis e identifica as ferramentas e os processos a serem usados no desenvolvimento.
Receber as contribuições de todos os membros da equipe
Trabalhe com suas equipes de arte, engenharia, design, áudio e produção para identificar e gravar tarefas de implementação. Por exemplo:
- As equipes de arte podem criar textura de recursos e orçamentos de malha para personagens e ambientes.
- A engenharia pode determinar checkpoints de memória e desempenho para criar perfis em cada plataforma.
- O design pode planejar a mecânica do jogo que possibilita a experiência.
- Especialistas em áudio podem analisar os requisitos de continuidade do som entre sons espaciais da interface, 2D e 3D.
- A produção pode comunicar os requisitos de lançamento e manter a equipe alinhada e no caminho certo.
Design para dispositivos móveis
O desenvolvimento de aplicativos em plataformas para dispositivos móveis envolve considerações específicas, como:
- Proporções de tela variáveis
- Consumo de energia
- Limitação térmica e do processador
- Entrada por toque
- Desenvolvimento multiplataforma
- APIs gráficas (Vulkan ou OpenGL ES)
Para ver detalhes sobre considerações exclusivas do design para dispositivos móveis, consulte Desenvolvimento Android no Unity do Unity e na Academia do Google Play.
Desenvolver e testar
Na fase de desenvolvimento e teste, você cria seu jogo e faz os testes e a preparação do pré-lançamento. Você faz alguns testes internos limitados no Google Play para se preparar para atender aos requisitos de lançamento. Você refina sua estratégia de implantação e organiza os recursos no Unity com base nos sistemas Play Asset Delivery e Addressables do Unity (links em inglês).
As seções a seguir descrevem as ferramentas e técnicas do Unity projetadas para ajudar você a desenvolver para o Android.
Renderização
A renderização é o processo de desenhar os recursos 3D e 2D da cena do Unity na tela. Embora o mecanismo do Unity processe a renderização, é importante considerar alguns fatores para a Plataforma Android.
Texturas
Determine se você precisa dos maiores tamanhos de textura com base nos dispositivos de destino. Ao criar o perfil de alocação de memória, analise as possíveis economias de mudar o tamanho da textura de destino.
Tempo para a renderização do frame
Para evitar o superaquecimento em dispositivos Android, segmente valores de tempo para a renderização de frames abaixo de 21 milissegundos, em média. Às vezes, como durante o carregamento ou em experiências cinematográficas curtas, o tempo para a renderização do frame pode exceder 21 milissegundos, mas é necessário permanecer abaixo do limite de 21 milissegundos para a experiência principal do jogo.
Em plataformas para dispositivos móveis, o VSync forçado limitará o frame rate se você não atingir o valor mínimo desejado. Por exemplo, em uma atualização de tela de 60 Hz, se você não atingir 60 fps, o jogo será limitado a 30. Se não chegar a 30, o limite será de 15.
Muitos dispositivos Android vêm com taxas de atualização de tela de 60 Hz e 120 Hz. Avalie os benefícios de segmentar tempos de renderização muito menores (meta de 10 ms para atualização de 60 Hz e 5 ms para 120 Hz) sem arriscar a limitação térmica e o consumo de bateria para taxas de renderização mais altas.
Para definir um frame rate específico no jogo em Unity, use Application.targetFrameRate.
A biblioteca Frame Pacing do Android ajuda a renderizar com facilidade quando o aplicativo demora mais para apresentar o próximo frame do que a taxa de atualização da tela exige. Para as versões 2021 e mais recentes do Unity, ativar o ritmo de frames do Android define a taxa de atualização da tela como a melhor correspondência para o frame rate desejado. Isso garante que o jogo não desperdice energia da bateria em atualizações desnecessárias da tela.
Para ativar a biblioteca, em Project Settings > Player, em Settings for Android, marque a caixa de seleção Optimized Frame Pacing.
Vulkan API
A Vulkan é uma API de gráficos 3D para várias plataformas e alto desempenho que tem baixa sobrecarga em comparação com o OpenGL ES. O Unity pode usar o Vulkan de duas maneiras diferentes.
API Auto Graphics
Você pode usar a API Auto Graphics com o Vulkan, mas ela pode ter comportamentos diferentes, dependendo da versão do Unity que você instalou. Para selecionar essa opção, acesse Project Settings > Player > Renderer.
Lembre-se das seguintes considerações ao escolher qual versão do Unity usar:
- O Unity 2021.1 e as versões anteriores não oferecem suporte a Vulkan com a API Auto Graphics. O Unity tenta usar o OpenGL ES 3.2. Se o dispositivo não oferecer suporte ao OpenGL ES 3.2, o Unity voltará para o OpenGL ES 3.1, 3.0 ou 2.0, nessa ordem.
- O Unity 2021.2 e as versões mais recentes usam primeiro o Vulkan. Se o dispositivo não oferecer suporte ao Vulkan, o Unity voltará para o OpenGL ES 3.2, 3.1, 3.0 ou 2.0.
APIs gráficas manuais
Como alternativa, você pode ativar o Vulkan manualmente, desativando a API Auto Graphics. Se você está usando o Unity 2021.1 ou uma versão anterior, essa é a única maneira de usar o Vulkan.
Se o Vulkan tiver uma classificação mais alta nessa lista do que o OpenGL ES, primeiro o Unity tentará usar o Vulkan. Se o dispositivo não for compatível com Vulkan, o Unity será executado com o OpenGL ES. Consulte Introdução ao Vulkan para informações detalhadas sobre o Vulkan no Android, por exemplo, como usar APIs gráficas modernas e otimizar o desempenho do jogo.
Chamadas de desenho
Tudo que aparece na tela está associado a uma ou mais chamadas de desenho. Em plataformas para dispositivos móveis, otimize e reduza o número de chamadas de desenho enviadas para a unidade de processamento gráfico (GPU).
Pense nas chamadas de desenho como carros alinhados em um semáforo. Depois que a luz ficar verde, um determinado número de carros poderá passar antes que ela mude. Quando a luz ficar amarela, você atingiu o tempo para a renderização do frame ideal (21 milissegundos) e, quando a luz ficou vermelha, você atingiu o limite de tempo para a renderização do frame de 33 milissegundos. Qualquer coisa depois que isso afetar o próximo frame de renderização, de modo que o frame rate resultante será menor que os 30 QPS desejados.
Para saber mais sobre como melhorar o desempenho da chamada de desenho no seu jogo, consulte o artigo sobre lotes do suporte do Unity.
Sombras
As chamadas de desenho da transmissão de sombra podem ser as que mais consomem GPU, consumindo mais tempo de GPU, mesmo em ambientes simples. Para reduzir o custo das chamadas de desenho da criação de sombras, experimente usar sombras rígidas em vez de suaves. Se isso ainda for muito caro na GPU para dispositivos mais simples, considere usar sombras de blob em vez de sombras rígidas.
Textura
O formato de compactação de textura recomendado para texturas RGB e RGBA no Android é ASTC. No Unity, a opção mínima de compactação de textura que precisa ser usada no Android é o ETC2. Você pode voltar para o ETC2 como backup do ASTC em Unity Build Settings.
Veja uma lista completa de formatos com suporte por plataforma na documentação do Unity em Manual: formatos de textura recomendados, padrão e com suporte por plataforma (link em inglês).
Interface do usuário e proporções
Você pode usar a ferramenta Device Simulator do Unity para visualizar várias resoluções de tela, orientações e proporções de dispositivo diretamente no Unity Editor. Você pode alternar entre a visualização de jogos e a visualização do simulador de dispositivos.
Confira uma prévia da ferramenta em Simular seu jogo com o simulador de dispositivo no Unity.
O código-fonte do Trivial Kart está no repositório games-samples (link em inglês) do GitHub.
É possível verificar rapidamente o layout e a precisão dos elementos da tela da interface na visualização do Device Simulator selecionando as opções do dispositivo no menu suspenso:
Para mais técnicas de otimização de IU para Unity, consulte o tutorial a seguir do Unity: Como otimizar a IU do Unity (link em inglês).
Física
O mecanismo Nvidia PhysX é integrado ao Unity. As configurações padrão podem ser caras em dispositivos móveis. Portanto, lembre-se das seguintes considerações:
- Considere o frame rate desejado e defina o intervalo fixo de acordo com ela. O padrão é definido como 0,02ms ou 50Hz. É possível aumentar para 0,03 ou mais para uma meta de 30 QPS.
- Considere simplificar os colisão de malha e minimizar a matriz de colisão de camadas para determinar as interações entre objetos do jogo de tipos de camada específicos.
Para saber mais sobre configurações de física e otimizações para jogos para dispositivos móveis, consulte o e-book "Otimize seus jogos para dispositivos móveis" (em inglês) do Unity.
Perfil
Os desenvolvedores geralmente ignoram ou ignoram a criação de perfil até que o aplicativo alcance um ponto crítico de falha. É uma boa ideia agendar um tempo dedicado de criação de perfil no seu processo e usar as seguintes práticas recomendadas:
- Identifique os principais pontos durante o desenvolvimento em que é possível alocar o tempo de criação de perfil, em vez de ajustá-lo aleatoriamente.
- Salve snapshots de perfil para usar com o Analisador de perfil do Unity.
- Crie o perfil do seu jogo nos dispositivos de destino para ter uma ideia precisa do desempenho do jogo no estágio de desenvolvimento atual.
- Criar o perfil de diferentes partes do jogo
- Analise a forma como seus usuários jogam. Não crie perfis do jogo apenas quando ele estiver em estado inativo ou em uma tela de pausa.
- Criar perfil no modo sustentado após a execução do jogo por um tempo para ajudar a encontrar problemas de limitação que podem ser encontrados quando os dispositivos móveis estão quentes.
É possível usar as seguintes ferramentas de criação de perfil separadamente ou em conjunto.
Unity Profiler é uma ferramenta de análise de desempenho totalmente integrada que pode ser executada no seu código no Editor do Unity e conectada ao dispositivo Android autônomo que executa builds do modo de desenvolvimento.
Android GPU Inspector (link em inglês) Com o Android GPU Inspector (AGI), você pode realizar a depuração no nível do frame. O AGI também analisa os serviços do sistema, incluindo contadores de GPU, CPU, memória, bateria e GPU.
Para conferir detalhes sobre como criar perfis no seu jogo no Unity, assista ao vídeo Introdução à criação de perfis no Unity (link em inglês) ou leia o Guia completo para criar perfis de jogos do Unity (link em inglês), ambos no Unity.
Gerenciamento de memória
Os processos do Android compartilham a memória disponível no dispositivo de destino. Crie o perfil do uso da memória quando o dispositivo de teste de destino tiver amplos recursos de memória livres. Realize testes de memória em um ponto consistente do jogo para comparar as sessões e as tendências de uso de memória adequadamente.
Ao trabalhar em scripts escritos em C#, tenha cuidado ao usar strings, comparações de strings e alocações de objetos relacionados a strings (como arquivos JSON para configurações de jogos). Elas geram alocações de memória frequentes e podem contribuir para a fragmentação.
Considere usar a classe
StringBuilder
para grandes sequências de manipulação de strings, em vez de concatenação de
strings no local (como "esta" + "é" + "a" + "ruim" + "ideia" versus
chamadas de função StringBuilder.Concat()).
Para saber mais sobre strings, consulte Strings e texto na documentação do Unity.
Avalie os recursos de texto JSON e TextAsset em relação ao tipo
ScriptableObject preferencial. O ScriptableObjects processa o armazenamento de dados entre cenas
com eficiência e permite modificações do tempo do Editor para o Google Play.
Para conferir uma discussão sobre o uso de alternativas ao identificador JSON padrão para otimização de dispositivos móveis, consulte o artigo A otimização oculta em jogos de rede (link em inglês) no Hutch.
Use a API Memory Advice para determinar o uso da memória durante a execução. A API expõe um indicador de semáforo para uso alto, normal e baixo da memória. Você pode se inscrever no indicador para receber atualizações ou pesquisar diretamente para saber o status atual. Quando você receber um sinal vermelho, considere reduzir o pool ou o cache de objetos do jogo. Inclua esse contexto na telemetria do jogo durante as operações em tempo real e na análise das métricas de desempenho após o lançamento.
Para saber mais sobre a organização da memória em dispositivos Android e como o Unity trabalha com ela, assista ao vídeo Noções básicas sobre o uso da memória no Android (do Google I/O 2018) (em inglês). O vídeo mostra os tipos de problemas de memória e quando o eliminador de baixa memória entra em vigor.
Coleta de lixo
A coleta de lixo em um ambiente de memória gerenciada limpa os fragmentos de memória não utilizados que podem ser reciclados para um aplicativo. Siga as práticas recomendadas de coleta de lixo para evitar alocações desnecessárias de recursos de memória.
Por exemplo, crie um pool de objetos de jogos em vez de usar alocações
sob demanda (GameObject.Instantiate). Para pools grandes, considere
alocar em vários frames para reduzir o risco de o jogo não responder
em dispositivos Android básicos.
Considere o snippet de código a seguir para uma corrotina simples que é invocada desde o início de um MonoBehaviour:
// Option 1: Bad for memory management - causes allocation each iteration
IEnumerator UpdateEnemyTarget() {
while (enabled) {
yield return new WaitForSeconds(1.0f);
// Some intermittent function check
}
}
// Option 2: Better for memory management - allocation of yield instruction once, reused each iteration
private YieldInstruction waitForSecond = new WaitForSeconds(1.0f);
IEnumerator BetterUpdateEnemyTarget() {
while (enabled) {
yield return waitForSecond;
// Some other intermittent function
}
}
É possível
editar
o arquivo de modelo MonoBehaviour para remover as funções de stub Start() e
Update() padrão. Assim, você não vai deixar as funções vazias
inadvertidamente enquanto desenvolve.
Para ter uma visão geral da ordem de execução dos eventos MonoBehaviour, consulte Ordem de execução para funções de evento na documentação do Unity. Para saber mais sobre gerenciamento de memória, consulte o curso Gerenciamento de memória no Unity.
Para conferir dicas de otimização de desempenho de jogos para dispositivos móveis, consulte Otimizar o desempenho de jogos para dispositivos móveis: dicas dos principais engenheiros do Unity sobre criação de perfil, memória e código.
Pool de prefab
Os picos de tempo para a renderização do frame são causados quase que totalmente pela instanciação do Prefab durante o jogo. Considere pré-aquecer pools de objetos para projéteis, inimigos gerados e efeitos visuais antes de entrar no jogo para reduzir ou eliminar os picos da CPU de inicialização. Você pode distribuir outras otimizações em vários "frames de inicialização" durante as sequências de carregamento ou de introdução na cena.
É possível encontrar muitos recursos de pool de terceiros na Unity Asset Store relacionados ao gerenciamento de pool de objetos de jogos. criar suas próprias opções. Consulte Introdução ao pool de objetos no aprendizado do Unity.
Envio de recursos
Há limites de tamanho para o aplicativo quando ele é implantado pela primeira vez no Google Play. Dependendo do tamanho e da natureza do jogo, você pode precisar de alguns ou todos os recursos (modelos de personagens, ambientes, elementos da interface etc.) para que os jogadores tenham a experiência pretendida.
Você pode usar o serviço Play Asset Delivery (PAD) para gerenciar os recursos exigidos pelo jogo no momento da instalação, de exibição rápida ou sob demanda. Os pacotes de recursos do Unity são integrados para oferecer suporte ao PAD, e você pode usar a ferramenta para especificar quais elementos são enviados.
Addressables
A configuração de recursos dinâmicos, como prefabs, texturas e arquivos de som, no momento da execução não é mais uma operação complexa se você preparar e revisar o sistema de nomenclatura Addressables. Os recursos endereçáveis dissociam a maneira como você organiza o conteúdo e como cria e carrega ele. O sistema Addressables substitui as pastas Resources e os Asset Bundles para simplificar a forma como você referencia os recursos e os carrega no ambiente de execução.
Por exemplo, consulte o Projeto de demonstração usando o pacote Addressables (em inglês) no GitHub. Para saber mais sobre o desenvolvimento de Addressables, consulte o Addressable Asset System do blog do Unity (link em inglês).
Com o layout de recursos Addressable, há vantagens e desvantagens em agrupar poucos ou muitos recursos em pacotes comuns. Para saber mais sobre o gerenciamento de conteúdo com Addressables, consulte Simplificar o gerenciamento de conteúdo com Addressables.
Você pode configurar uma
demonstração independente e testar os modos de acesso para se acostumar
com o sistema Addressables. Você também pode conferir o projeto de código aberto
BuildLayout Explorer para Unity 2019.3 e versões mais recentes
e inspecionar o relatório buildlayout.txt gerado pelo
Addressables.
Os recursos do Chop Chop, um projeto Open do Unity, foram empacotados usando o sistema Addressables para todo o carregamento e descarregamento. Consulte Como empacotar conteúdo com recursos endereçáveis | Devlog de projetos abertos para conferir um tutorial da estrutura e da configuração dos pacotes do Addressables.
No projeto Chop Chop, a única cena carregada por padrão, a cena
de inicialização, foi configurada para usar AssetReferences em vez de links diretos para recursos no
projeto (cenas, prefabs e assim por diante).
O código-fonte do Unity Open Project: Chop Chop está disponível no GitHub (link em inglês). Embora o projeto não esteja mais em desenvolvimento, o repositório do Git e a documentação ainda estão disponíveis.
Plug-ins de terceiros
Se você usa plug-ins de terceiros, como os do Unity Asset Store, analise as pastas e remova recursos desnecessários das pastas Resources. Durante o processo de build, o Unity coleta todos os recursos incluídos nas pastas Recursos e os empacota em um único pacote que pode ser acessado no momento da execução. Isso pode adicionar sobrecarga ao pacote final e geralmente não é necessário.
Para localizar rapidamente todas as pastas de recursos, pesquise Recursos no painel Projeto. Em seguida, você pode selecionar cada um para identificar o que ele contém e se ele é necessário para o jogo.
Publicar e manter
Quando estiver tudo pronto para lançar seu jogo para dispositivos móveis, decida para quem você quer fazer o lançamento, como fazer testes Alfa e Beta e como monitorar e acompanhar o desempenho após o lançamento.
Analisar o feedback de uma versão limitada
Você pode fazer o lançamento para um público limitado e segmentado e realizar testes Beta em grande escala ou ativar seu jogo para disponibilidade total em todos os mercados. Com uma versão limitada, você pode ajustar o desempenho do seu aplicativo com base em um público ao vivo mais amplo e um conjunto de dispositivos.
Por exemplo, você pode usar o Android Performance Tuner para Unity e o Google Analytics para Unity para receber insights sobre o desempenho do app e as tendências dos jogadores, com que sua equipe de desenvolvimento pode ajustar e enviar atualizações. Também é possível usar seus dados de análise para planejar sequências ou jogos relacionados de um gênero semelhante.
Testes Alfa e Beta
Depois de configurar o perfil do aplicativo no Google Play Console, você poderá preparar builds públicos de teste Alfa e Beta e distribuí-los a um público limitado para revisão de pré-lançamento. Ao lançar para um público limitado, é possível resolver os problemas finais com um conjunto maior de dispositivos e coletar feedback inicial para responder antes de lançar um lançamento global.
Seus builds do Unity são distribuídos pelos Android App Bundles. Para mais informações, consulte o Manual: como entregar no Google Play do Unity, que também descreve as mudanças dos arquivos APK para o formato AAB.
Monitorar e acompanhar
Durante a fase de ativação e distribuição do jogo, você pode usar o Android vitals para rastrear problemas de desempenho em dispositivos a que você não teve acesso durante o desenvolvimento e os testes. Para mais detalhes, assista a Novidades para jogos no alcance e dispositivos e no Android vitals.
Geralmente, as equipes de desenvolvimento maiores têm pipelines de telemetria de jogos exclusivos e personalizados que fornecem métricas relacionadas ao desempenho do dispositivo. Não se esqueça de aproveitar o Android Performance Tuner (APT) e o plug-in correspondente do Unity para acessar métricas de discagem relacionadas a frame rates, fidelidade gráfica, tempo de carregamento e abandono no carregamento. Siga o guia explicativo em Integrar o Android Performance Tuner ao seu jogo do Unity.
O ciclo de vida do seu jogo não para depois que você entra no ar. Monitorar, manter e responder ao desempenho e ao feedback são essenciais para usuários satisfeitos, avaliações positivas e adoção final do jogo em todos os mercados.