Otimização | Boas práticas no código!

A Otimização estará sempre presente ao longo da carreira de um programador, principalmente de jogos!

Pois, um código mal otimizado pode destruir completamente a performance dos seus jogos!

E entregar uma experiência péssima para os jogadores, então já a anota as dicas a seguir.

Otimização : Debug.Log

Cada mensagem registrada no Debug.log é armazenada na memória temporária.

E isso até que o jogo seja fechado ou o log, seja limpo.

Mas, se muitas mensagens forem registradas repetidamente, especialmente em loops.

E até em situações de alta atividade, isso pode resultar em um Impacto no desempenho da memória.

E o maior problema em si, é esquecer um Debug perdido no meio do código após buildar o game.

Pois, isso consumirá desempenho do jogo mesmo sem um console em tela.

Otimização : Usar strings

Strings são muito importantes em inúmeras situações durante o desenvolvimento, mas precisam ser usadas com cautela.

Pois, a depender do comando usado o sistema irá comparar cada carácter da palavra.

Mas, até encontrar a resposta exata, e essa comparação é custosa para o processamento do jogo.

E aqui evite usar constantemente concatenação de strings, comparações, conversões.

E formatações, especialmente evite deixar em Updates, por exemplo.

Otimização : Start vs Awake

Um problema relativamente comum em alguns jogos, é aquela travada ao iniciar uma cena no jogo.

E isso ocorre devido à quantidade imensa de operações realizadas na mesma função, como referências, por exemplo.

E aqui é interessante analisar as referências que seu jogo faz no início.

Mas, principalmente buscar dividir entre Awakes e Starts, que são as primeiras funções a serem executadas ao inicializar.

E dessa forma essa “Travada”, pode reduzir consideravelmente devida a caga baixa de execuções na mesma função.

Referenciar manualmente

É possível optar por fazer uma referência manual dos componentes conforme for codificando.

E assim evitar usar os Starts e Awakes excessivamente ao iniciar a gamepley.

Pois, por mais que dê, um pouco mais de trabalho manual, o jogo terá menos componentes para referenciar ao inicializar.

E a depender do tamanho da cena do seu jogo, isso pode acelerar demais a inicialização.

E deixar as referências automáticas via script, só quando realmente for necessário.

Otimização : Getcomponents

GetComponent realiza uma busca pelos componentes anexados ao GameObject.

E faz isso percorrendo uma lista e verificando se o componente desejado está presente.

E dependendo do número de componentes anexados, isso pode ser custoso em termos de desempenho.

Portanto, evite o uso excessivo desse comando, principalmente em Updates.

Pefira os Starts ou Awakes, por exemplo.

E uma otimização seria o TryGetComponent, que retorna uma Bool ao invés de um NullReferenceException.

Otimização : Find Objects

Os FindObjects como: FindObjectsOfType, GameObject.Find.

E GameObject.FindGameObjectWithTag, podem ser um tanto quanto problemáticos.

Pois, essas funções percorrem todos os objetos de jogo na cena.

Ou todos os componentes de um tipo específico, por exemplo.

E por usarem comparações com strings muitas vezes, isso é muito custoso em termos de desempenho.

E especialmente em cenas grandes e complexas, sendo melhor escolha referencias manuais.

Otimização : Update

Podemos enfrentar problemas de desempenho também por simplesmente escolher funções erradas a serem usadas.

Por exemplo, o Update é chamado a cada frame.

E logo, se o jogo está a 60 FPS, o Update é lido 60 vezes por segundo.

Mas, se for a 45 FPS, ele é lido 45 vezes, e assim por diante.

Portanto, ele é mais recomendado para executar funções de movimentação através do Transform do objeto.

E que não use a física, e até fazer a leitura dos inputs com muito mais precisão.

Fixed Update

O comportamento da física de um jogo é extremamente importante.

E precisa ser igual em qualquer dispositivo, independente se estiver a 30 ou 240 Fps, a física deve ser a mesma.

E o FixedUpdate é chamado em intervalos fixos de tempo, o que proporciona uma simulação de física mais consistente.

Mas, isso independentemente da taxa de quadros do jogo.

E sendo a função mais recomendada para lidar com cálculos relacionados à física.

E movimento de objetos no Unity que usem o Rigidbody e sua funções.

Loops Infinitos

Um loop infinito ocorre quando uma sequência de instruções é executada continuamente sem nunca atingir uma condição de parada.

E eles podem causar problemas significativos no desempenho e na estabilidade do seu projeto, congelamento, travamentos, etc.

E aqui, evite usar laços de repetição soltos em Updates.

Ou seja, sem estar em um if, que impeça sua chamada constante.

E principalmente que suas condições também possam ser atendidas.

Instantiates e Destroys

Essas operações envolvem a criação e destruição de objetos no Unity e causam muitas alocações e liberações de memória.

Pois, ao instanciar, o sistema aloca uma memória para esse objeto.

E ao destruir, essa memória precisa ser liberada, incluindo atualizar listas internas de objetos, componentes, sistemas de eventos, etc.

E deixam resíduos na memória, que precisa ser limpo pelo sistema de gerenciamento de memória.

Mas, que causam pausas perceptíveis no jogo, ou os famosos “stutterings”.

Object Polling

Para minimizar o impacto no desempenho causado por Instantiate e Destroy, você pode usar técnicas como o “Object Pooling”.

E consiste em reutilizar objetos pré-criados em vez de criar e destruir constantemente novos objetos.

E apenas ir ativando e desativando quando necessário.

Pois, isso reduz a alocação e liberação de memória, bem como a sobrecarga do gerenciamento de objetos.

Mas, principalmente melhorando o desempenho geral do jogo.

Dividir para conquistar

É melhor criar um script que seja responsável por uma única função, do que poucos scripts.

Mas que executam inúmeras funções no projeto.

Pois, a medida que o jogo crescer, será muito mais difícil de fazer a manutenção do seu código.

E identificar bugs ou falhas prejudiciais ao projeto.

E uma dica muito bacana para você, que tem interesse em aprender mais sobre a Unity e a sua linguagem C#, essa é a sua chance.

Pois, temos um curso sensacional que te mostra a base da programação na Unity.

E de quebra você ainda vai desenvolver um jogo top down com sistema de diálogo, crafts, inimigo e muito mais.

E o mais impressionante, por um preço extremamente baixo, isso mesmo…Dúvida?

Basta clicar na imagem ao lado para saber tudo sobre esse curso incrível!

Logo abaixo deixaremos um vídeo com mais detalhes sobre as melhores práticas!