Mathf || A classe matemática que te ajuda a criar jogos!

Para criar jogos é necessário sim o uso de matemática, afinal a Engine está constantemente realizando cálculos.

Porém, qualquer pessoa pode começar na área sabendo o básico de matemática e tendo uma boa lógica de programação.

E nesse artigo vamos conhecer melhor a classe matemática que já vem prontinha, disponível para o uso.

Classe matemática da Unity.

Uma das grandes vantagens de se utilizar uma Engine pronta, é que já traz consigo sistemas complexos e avançados.

Por exemplo, o próprio sistema de física, que se fosse criado do zero exigiria um alto conhecimento matemático.

E isso possibilita que qualquer pessoa, possa criar seus jogos com um conhecimento básico de cálculos.

E ainda por cima existe uma classe Matemática especificamente para realizar cálculos mais avançados.

Porém, um profissional que queira se destacar no mercado, também precisa estudar matemática avançada.

Pois, fará um melhor uso da Engine e também compreenderá melhor a classe matemática chamada Mathf.

Os Mathfs na Unity

Essa classe possui algumas funções, que realizam cálculos específicos e que são muito úteis para nossos jogos.

E aqui listaremos algumas delas, que são bem úteis e bastante utilizados em diversas mecânicas.

Mathf.Abs:

Esta função nos retorna um valor absoluto de um determinado cálculo, e sem dúvidas é bastante útil.

Pois, caso o valor seja negativo ele sempre retornará para nós positivo, ou seja, se for -2.4 ele retornará 2.4 positivo.

E pode ser aplicada de diversas formas, por exemplo, para saber se o player está se movendo.

Porque bastaria colocar o Input que varia de 1 e -1, nesse Mathf e ele retornaria 0 parado e 1, se movendo.

Mathf.Clamp:

Esta função é usada para limitar algum cálculo entre valores específicos que você determinar.

Caso você precisa que determinado resultado não saia de -4 e 4, ou 5 e 25, por exemplo, você pode usar o Clamp.

E um uso comum, seria em jogos que precise limitar a movimentação do player dentro de uma área.

Mathf.Clamp01:

Já esta função é muito parecido com o Clamp padrão, porém, com a diferença que ele já vem com os limites definidos.

E que neste caso é entre 0 e 1, assim como a descrição do seu nome nos sugere, mas fazendo o mesmo efeito.

Então você precisa avaliar bem em qual situação se enquadraria o melhor clamp, para a sua mecânica.

Mathf.Sign:

Esta função nos retorna 1 caso o valor seja maior ou igual a 0, e -1 caso o valor seja menor que 0.

Podendo ser muito útil para descobrir se os valores retornados em algum cálculo, estão positivos ou negativos.

Mathf.DeltaAngle:

Esta função nos retorna o menor angulo existente entre 2 ângulos que você queira calcular.

Este comando pode ser usado para calcular a trajetória de bullets, ou objetos arremessáveis em seu jogo.

Mathf.Floor:

Esta função retorna o menor igual valor inteiro do resultado, ou seja, fazendo o arredondamento do valor.

Porém, existe um detalhe, perceba que ele arredonda para o inteiro menor mais próximo do valor.

Por exemplo, se o resultado for 37.97, ele não arredonda para 38 e sim para 37, por ser o inteiro menor do resultado.

Mas caso seja -37.97, ele arredondaria para -38, que é o inteiro menor mais próximo do valor -37.97.

Mathf.Round:

Já o Round faz arredondamentos mais comuns, onde valores quebrados maiores ou iguais a 5, são arredondados para cima.

Por exemplo, 3.5, 3.64, 3.76, 3.97, etc, seriam todos arredondados para o inteiro acima, 4 no caso.

E para resultados quebrados menores que 5, são todos arredondados para o inteiro menor.

Por exemplo, 3.49, 3.32, 3.27, 3.1, etc, seriam todos arredondados para o inteiro 3.

Mathf.Lerp:

Esta função faz uma intercalação entre 2 valores suavemente, sendo muito utilizado em movimentações de objetos.

Pois, você passa 3 parâmetros, o valor inicial, um valor final e um valor de tempo, para que seja realizado a intercalação.

E o cálculo irá aproximar suavemente o valor inicial até chegar no valor final ou muito próximo a ele.

E na movimentação ele faz o objeto acelerar suavemente, até atingir uma velocidade constante, e desacelerar no final.

Mathf.LerpUnclamped:

Já esta variação do lerp, traz também uma certa suavização no fim do movimento como o Lerp padrão.

Porém, ele faz a aceleração e a movimentação de forma linear, ou seja, movendo sempre a mesma unidade de distância.

Mathf.MoveTowards:

O MoveTowards ele também é bastante utilizado em movimentações de objetos, requerendo os mesmos parâmetros.

Porém, com ele não terá suavização, nem no início e, nem no final da interpolação de valores.

Com ele o movimento do valor inicial sai bruscamente e ao chegar no valor final, para bruscamente também.

Mathf.Max:

Esta função pede dois valores para comparação, e retornara para nós o maior valor entre os comparados.

Por exemplo, se os valores forem 5 e 8, ele retornará para nós o valor 8 que é o maior entre os comparados.

E pode ser muito útil em mecânicas de Danos por combos, passando valores aleatórios e nos retornando o maior deles.

Mathf.Min:

Esta função funciona igualmente ao Max, porém, por sua vez nos retornará o valor mínimo da comparação.

Tanto o Max quanto o Min, podem ser muito úteis em diversas mecânicas, aliados a números Randômicos.

Pode trazer uma variabilidade ainda maior em resultados para danos, combos, ataques críticos, etc.

Mathf.Approximately:

Esta função faz uma comparação de um valor e com algum outro valor, ou resultado de algum cálculo.

E nos retorna um resultado boleano se os valores são aproximados ou não, podendo ser usado até em um if.

Por exemplo, temos o valor 7, e queremos comparar se o 7 é similar ao resultado do cálculo, 15 dividido por 2.

Neste caso, esse Mathf retornaria false, pois, 15 dividido por 2 é 7.5, então você realizaria alguma ação a partir daqui.

Mas se o valor a ser comparado fosse 7.5, ai sim teríamos um retorno de verdadeiro para essa comparação.

Mathf.Sqrt:

Esta função nos retorna a raiz quadrada de qualquer valor que precisarmos, facilitando demais nossa vida.

E até mesmo números que não possuem raiz quadrada exata, ele nos retorna o número quebrado aproximado.

Por exemplo, de 25 retornaria 5, e já de 30 nos retornaria o número quebrado em float de 5.477226.

Mathf.Pow:

Esta função faz o cálculo de um número elevado a um expoente nos retornando o resultado.

Então você passa no parâmetro dois valores, o primeiro é o número que você deseja calcular e o segundo o expoente.

Ou seja, se usarmos Mathf.Pow (2,3), teríamos o resultado de 8, pois 2X2 = 4, 4X2 = 8.

Mathf.PingPong:

Esta função não tem esse nome atoa, pois, seu resultado é exatamente a um Ping Pong de fato.

Pois, nele passamos um parâmetro de tempo ou um valor corrente que esteja aumentando, ou diminuindo.

Por exemplo, o próprio Time.time, que é o valor de tempo de jogo, e no segundo parâmetro o valor máximo.

E este valor máximo não pode ser menor que 0, pois, ele vai partir de 0 para o valor definido.

E ao ser executado ele subirá o valor até próximo ao valor máximo e retornará para próximo de zero.

Seguindo esse loop, e quando aplicado na movimentação o objeto sofre um efeito de ir e voltar, de um ponto a outro.

Mathf.Repeat:

Já esta função tem um efeito muito semelhante ao Mathf.PingPong, exigindo basicamente os mesmos parâmetros.

Porém, ao invés de ir de 0 ao valor máximo e retornar do valor máximo para 0 em loop.

O Repeat executa em loop também, mas sempre que alcança o valor máximo ele recomeça do 0.

Existem muitas outras funções na classe Mathf, mas trouxemos as mais comuns e mais utilizadas.

Você não precisa usar todas sempre, mas é interessante pelo menos entender o que cada uma faz.

Para poder usar em casos específicos, facilitando possíveis cálculos matemáticos que venha a precisar realizar em seus jogos.

Deixaremos um vídeo abaixo falando mais da real necessidade de saber matemática para criar jogos.