Unity Mobile parte 1: jogos para celular com persistência de dados

Manipulando vetores - Introdução

E aí, tudo bom? Nesse curso a gente vai fazer aqui mais um projeto na Unity.

E dessa vez a gente vai fazer um projeto para celular. Então eu estou aqui com o meu celular ligado no computador via USB e a gente tem aqui o nosso jogo na Unity, o nosso Fuga Espacial, que é o projeto que a gente vai fazer nesse curso.

Então, se eu der um play aqui na Unity o nosso jogo vai passar para o meu celular. Então eu consigo jogar ele por aqui. E se eu clicar em jogar a gente vai ver o nosso jogo.

E qual é o objetivo desse jogo? Bom, eu tenho uma nave, que eu deslizo com o meu dedo, você pode ver que ela está deslizando. E eu tenho esse monte de bolinha branca que vai vir na minha direção e a gente tem que desviar delas e fazer elas baterem nesses meteoros aí que estão no meio da tela.

Se a gente fizer isso, a gente vai ganhar um ponto. Se a gente bater em alguma coisa, ela vai destruir a gente e a gente vai para uma outra cena.

Então, se eu jogar um pouco, a gente vai ver que eu fiz alguns pontos. Eu fiz sete pontos e a gente agora vai fazer também essa tela de Ranking.

Então eu vou ter uma tela de Ranking onde a gente tem os melhores colocados. Então a gente tem aqui, o Bruno fez dezoito pontos, a Alice fez dezessete, a Laura fez treze, o Ricardo fez nove, a Mayra fez seis e a gente tem essa lista de colocados sendo salva permanentemente no nosso computador.

Então a gente vai ver nesse curso como a gente salva um arquivo de maneira persistente para, se eu fechar o computador, desligar ele e reiniciar no dia seguinte...ou se eu desligar o meu celular, perder a bateria, fizer qualquer coisa com ele, quando eu voltar para o meu celular eu vou ter meu jogo com as informações salvas. Com as melhores partidas salvas.

E aí, para tudo isso a gente vai ver como a gente debuga nosso jogo dentro do nosso celular então, como a gente faz essa conexão. A gente vai também fazer o nosso jogo a partir de um projeto já criado.

Então eu tenho aqui a Unity e a gente vai ter um projeto com algumas coisas já, porque a gente já viu em vários outros cursos como fazer essas coisas.

Então nesse projeto a gente vai começar um pouco para frente para a gente conseguir focar no que a gente quer.

Então a gente vai ter nossa cena de jogo onde ela vai ter o gerador de inimigos que a gente já viu em outros cursos. A gente vai ter as barreiras aqui na cena. E a gente vai ver a nossa nave, essa nave que a gente vai mover. Então eu vou chamar aqui de jogador.

A gente vai criar os scripts para ela. No caso, a nossa nave vai seguir o mouse. ou vai seguir a posição do nosso dedo. Que a gente vai ver como faz isso também nesse curso.

Além disso, a gente vai ter a nossa pontuação. E a gente vai ter aquele Unity Vent, que a gente já tinha criado, passando uma informação dinâmica para a gente conseguir atualizar a nossa interface. Então a gente vai fazer isso nesse curso.

Além disso, nossos inimigos que estão aqui na minha pasta de prefabs...então, se eu clicar em prefabs, e a gente vem em nosso inimigo, ele vai ter o script para seguir a nave. Então, se eu vier aqui e editar esse script, já que a gente vai trabalhar com código, eu vou ter aqui que o nosso inimigo, ele vai calcular o deslocamento dele em relação à nossa nave.

Então ele vai ter que saber quem é a nossa alvo, quem é esse alvo que ele está seguindo. E a gente vai ver como fazer isso. A gente vai trabalhar com vetores nesse curso.

E a gente também vai criar aquela cena de ranking. Então aquela última cena que a gente tem é a nossa cena de ranking. E para fazê-la a gente vai precisar saber quantos pontos a gente fez na cena de jogo. Então eu vou ver como passar informações entre as cenas da Unity. E quando a gente fizer isso eu vou ter aqui, se eu der o play de novo, a nossa cena de ranking sendo criada.

Então, se eu der o play, a gente tem aqui a nossa cena de ranking de novo criada. E esse arquivo vai ficar onde? Esse arquivo que a gente vai salvar, vai ser um arquivo no nosso computador.

Então a gente vai ver como criar esse arquivo, aqui. Um arquivo ranking.json, que vai ficar salvo de uma maneira fixa no nosso computador.

Então aqui a gente tem todas as entradas. O nome do primeiro colocado, que fez a quantidade de pontos. Então a gente tem aqui o Bruno, dezoito, Alice, dezessete, a gente tem todas as entradas e vamos fazer tudo isso nesse curso.

Então, eu sou o Ricardo Bugan, eu vou ser o instrutor e vamos aprender mais sobre Unity.

Manipulando vetores - Seguindo o mouse

E aí, tudo bom? Então nesse curso a gente vai fazer o nosso Fuga Espacial. Eu estou com ele aqui aberto. E dessa vez a gente vai começar um projeto com algumas coisas já nele, algumas cenas já montadas.

Então a gente tem nossas três cenas que a gente vai trabalhar nesse curso. A nossa cena de menu, que é a que eu estou aqui aberta. Então, se eu vier aqui e der um play nela, a gente vai ver que eu tenho o áudio tocando e eu posso vir aqui e clicar em jogar para a gente começar nosso jogo.

Então a gente vai ter essa transição de cena que a gente viu nos outros cursos. Aí a gente tem nossa cena de jogo, que por enquanto não faz nada, a gente vai implementar ela. Na verdade, ela está só gerando os inimigos aqui. E por fim a gente vai ter nossa cena de ranking.

Então, se eu vier aqui eu tenho nossa cena de ranking, onde a gente vai salvar as pontuações.

Mas vamos começar pela cena de jogo. Então, já que ela não está fazendo nada ou muito pouco...a gente tem aqui nosso jogador, nossa barreira, mas, se eu der o play, a gente viu que nossa nave não faz nada. Ela está aqui parada no meio da tela.

E se eu vier na cena a gente tem esse monte de bolinha branca que são nossos inimigos, são o desafio que a gente vai ter que enfrentar nesse jogo.

Então, a ideia é que eles venham e sigam a nossa nave para depois tentar destruí-la. E quem está gerando eles é o nosso gerador de inimigos, que a gente tem aqui o nosso tempo de geração, o raio, então a gente está definindo um raio para eles, e gente estava com o prefab do inimigo, que a gente também já viu o que é. É aquele manual de instruções de como criar o inimigo.

Mas a gente está com a nave parada no meio da tela e como vamos fazer para movimentá-la? A gente tinha pensado em falar que esse jogo é um jogo mobile ou seja, é um jogo que vai para celular e, se ele vai para celular, qual é a principal maneira de você interagir com o celular? É via toque.

Então, se eu quero fazer essa nave se mover, eu posso fazer ela com toque. É uma maneira muito prática de fazer isso. E como a gente vai simular o toque aqui na Unity? Como a gente vai fazer ela reconhecer o toque?

Bom, na Unity a gente está trabalhando aqui no computador, mas no computador a gente não consegue tocar na tela. Não posso vir aqui, clicar na tela e fazer as coisas acontecerem, pelo menos não no meu desktop, alguns notebooks fazem.

Mas, se a gente não tem essa possibilidade de clicar na tela dentro do nosso computador, como que a gente vai simular isso? Como a gente vai fazer a Unity reconhecer isso no computador e no celular? Já que a gente tem nosso ambiente de desenvolvimento no computador, mas o nosso ambiente de produção, onde a gente vai lançar o jogo é no celular?

A unity foi pensada e foi criada para a gente criar jogos em várias plataformas. Então, se a gente vier aqui no nosso painel de build, onde a gente gera o executável nosso jogo, então em build settings, a gente pode ver que eu tenho pc, Mac, Android, iOS, tv, Xbox...a gente tem muitas plataformas.

E como a gente tem várias plataformas e cada uma tem a sua maneira de entrada de dados, seja pelo mouse e teclado, seja pelo toque ou seja pelo controle, a unity já foi preparada para a gente usar isso. E para a gente fazer de uma maneira simples essa conversão entre uma plataforma e outra.

Então, com isso, o nosso mouse aqui do computador, representa o toque lá no celular. Então, se eu pegar a minha posição do mouse e falar que a minha nave tem a mesma posição que a posição do meu mouse, a unity consegue traduzir isso para que quando eu estiver no celular, a posição do meu mouse é igual à posição do toque do meu dedo, onde meu dedo está tocando.

Então, vamos lá na nossa pasta de scripts, na nossa pasta de game play, agora a gente tem várias pastas lá dentro e eu vou criar mais um script. A gente já tem o nosso gerador, já tem o evento de colisão, a gente vai ver daqui a pouco ele. E a gente vai vir aqui e criar um novo script, que vai ser o segue mouse.

Então esse segue mouse vai ser o script que a gente vai colocar dentro da nossa nave, que eu chamei aqui de jogador. Então, selecionei nosso jogador, vou clicar e arrastar o nosso script segue mouse. E vamos clicar aqui para editar o script. Então clica, editar script, o Visual Studio vai abrir e a gente vai conseguir fazer essa alteração.

Então a gente quer agora que a posição da minha nave seja igual à posição do meu mouse. E como eu quero que isso se repita o tempo todo, a gente vai aqui de novo usar o nosso método Update.

Então vamos vir aqui, deixar ele private, vamos colocar o modificador de acesso nele. É uma boa prática porque a gente deixa bem claro o que a gente quer fazer, o que é private e o que não é, o que é público e o que é protect no nosso código e aqui eu vou falar que a minha posição...então, quem guarda a posição dentro da unity é o transform, a gente já viu isso, que é aquele componente obrigatório de todos os objetos que estão dentro da minha cena...this.transform.position, isso vai ser igual à posição do meu mouse.

Então como que eu faço isso? Eu falo que a posição do meu mouse é igual a input, porque ele é uma entrada de dados, então ele é uma Input.mousePosition, posição do mouse em inglês, mouse position.

Então, a minha posição, a posição desse meu objeto vai ser igual à posição do meu mouse. Vamos salvar, voltar lá na unity, ela vai compilar o nosso jogo, e a gente vai ver, se eu der um play aqui, deixar meu mouse na tela e a minha nave sumiu da tela.

Bom, ela está seguindo alguma coisa. Vamos ver a posição dela? Se eu vier aqui no inspetor e clicar, a gente está com o jogador, que é minha nave, selecionada, a posição dela está em quinhentos e quarenta e cento e dezoito. Quinhentos e quarenta em x e cento e dezoito em y.

E aí, conforme eu ando aqui meu mouse pela tela a gente pode ver que a posição dela está mudando. Então, é um pouco pequeno, mas a gente pode ver, se eu chegar aqui para baixo, cinquenta em x e sessenta e sete em y.

Bom, e se eu chegar bem perto aqui dessa bordinha preta, dois em x e sete em y. E agora a gente foi para a tela de ranking. O que aconteceu? A nossa nave estava se movendo, mas pelo visto, essa posição em x aqui, essa posição do mouse é uma posição estranha, é uma posição muito maior do que a posição do nosso jogo.

Por que? Porque esse Input.mousePosition devolve para a gente essa posição do meu mouse em pixels. Ou seja, quantos pixels eu estou longe da minha origem da tela.

Por que? Porque a nossa tela é medida em pixels. Então, se aqui a gente viu que eu estava diminuindo meu x e meu y conforme eu chegava perto desse canto, isso indica que o zero zero da nossa tela estava aqui embaixo. E quando eu cheguei muito perto a gente foi para a tela de ranking.

Por que? Se o nosso jogador bater em alguma coisa, ele tem aqui no nosso script evento de colisão. Esse evento de colisão é um unity event que a gente já tinha visto. Então, quando bater, ao bater, ele vai pegar meu diretor de cena e vai pedir para ele ler a cena ou carregar a cena de ranking.

Por isso que a gente passou de cena. Porque eu estava chegando muito perto e eu colidi com um desses meteoros aqui no meio, com um desses asteroides. Mas, espera, se a minha posição do mouse é medida em relação a pixels, o quão longe eu estou desse zero zero aqui, como eu vou fazer para transformar isso em uma posição do meu mudo.

Porque a posição do meu mundo, a posição da minha nave, a gente pode ver, quando ela está dentro da minha câmera aqui, se a gente lembrar que esse contorno branco representa minha câmera, eu estou aqui no x menos zero ponto oito e no y menos um ponto vinte e oito.

Aqui no meio. E aí, se eu descer ali perto, onde é o zero zero em relação à câmera, eu estou no menos oito em x e menos quatro em y. E se eu for lá para cima, eu estou em nove ponto alguma coisa em x e cinco em y.

Então, a posição do meu mundo, a posição que a minha nave consegue se mover no meu mundo é diferente da posição que a câmera retorna para mim, a posição do meu mouse.

Então o que a gente vai fazer? A gente vai converter essas medidas. Eu preciso falar "olha, de algum jeito, pega essa posição do meu mouse em relação à tela que está em pixels e transforma ela em uma posição do meu mundo, que eu consiga reconhecer.

E quem faz essa interface entre a tela e o nosso mundo? Quem faz essa interface é a nossa câmera. A câmera sabe quem é o mundo e quem é a tela, porque ela pega as informações do mundo e desenha para a gente na tela.

Então, a câmera tem um método que faz essa conversão para a gente. Então, se eu criar uma variável que vai ser a posição, e eu vou falar que é igual...e aí eu tenho que pegar a minha câmera e como a câmera é uma coisa que a gente sempre tem em todos os nossos jogos, a gente precisa de alguma câmera para renderizar o nosso jogo, a gente consegue pegar, na classe câmera a propriedade main.

A câmera principal. Main vem de principal, da classe câmera, a minha câmera principal, a câmera que está ativa no meu jogo e eu vou pegar esta câmera principal e vou falar "olha, converte uma posição da minha tela para uma posição do meu mundo." Então pega um Screen point ToWorldPoint.

Então eu vou pegar um ponto da minha tela e transformar em um ponto do meu mundo. E que ponto que é esse? Esse ponto vai ser o meu Input.mousePosition, que ele me devolve um ponto.

Então vamos copiar isso aqui, colar ali, ponto e vírgula e agora a posição da minha nave não é igual à posição do meu mouse diretamente, é igual a essa variável posição que eu criei.

E aí, fazendo isso a gente pode ver que vamos ter aqui a nossa tela e de novo o meu jogador sumiu, minha nave sumiu. Mas, espera. Vamos lá de novo ver qual é a posição dele.

Então, vamos pegar a posição do meu jogador...menos dez e três. Menos dez e três parece estar em uma posição mais parecida com o que a gente estava lá.

Então se eu estou com meu mouse aqui no meio a gente pode ver que x zero e y menos um. Ele deveria estar aparecendo, mas ele não está. O que aconteceu?

Acontece que, se a gente olhar a posição...opa, bati em alguma coisa de novo. Jogar novamente. Se a gente voltar aqui, vamos abrir o meu jogador e ver a posição z dele, a gente está no menos dez.

Mas espera, eu não estou desenvolvendo um jogo 2D? Porque eu tenho a posição z aqui? Porque a Unity, apesar de deixar a gente desenvolver jogo 2D, e ela tem ferramentas para isso, ela não deixa de ser uma engine 3D.

E quando a gente pega e fala "olha, pega esse ponto da minha tela e transforma em um ponto do meu mundo", a câmera vai fazer isso, só que ela devolve a posição z dela.

E se a gente clicar aqui na cena, na posição da câmera, ela está na posição zero zero, com o z menos dez. Ou seja, ela pegou o ponto x dela, o ponto y dela, da tela em relação ao mundo, só que ela colocou também o z, ela colocou a profundidade dela.

Mas, espera, de onde vem essa profundidade? Bom, como eu falei, a Unity é uma engine que trabalha em 3D e se a gente clicar aqui nesse 2D, que é o modo que está ativado, a gente pode ver que temos o nosso mundo em 3D.

A gente ainda está usando todas as ferramentas de 3D dela e a nossa câmera você pode ver que ela está mais longe aqui do que nossa nave.

Então, ela tem aqui o nosso eixo x, o Gizmo do x, o Gizmo do y, que é a nossa altura e a gente tem esse z aqui que é a profundidade, quanto mais perto ou mais longe ela está em relação ao nosso zero zero, na profundidade.

Então, a gente está trabalhando com ela em 2D, mas ela ainda é uma engine 3D. E por isso que ela tem as três posições. Então vamos voltar minha câmera aqui para o zero zero e para o menos dez.

Vamos salvar isso...e como eu faço então para falar com a câmera desconsiderar a posição z dela? Porque esse Camera Screen Point devolve um Vector3, a gente consegue ver aqui. Ele devolve um Vector3 é um vetor de três posições. Só que eu não quero usar as três posições, eu quero ignorar a última. Como eu faço isso?

Bom, eu vou transformar esse Vector3 em um Vector2, porque o Vector2 só tem x e y, ele não tem o z. E como a gente faz isso? A gente faz um (CAST). Então eu vou abrir e fechar parênteses aqui e vou fazer esse (CAST), ou seja, a gente vai pegar aquele Vector3 e transformar em um Vector2.

Dessa maneira, na hora que a gente colocar a variável posição, ela só vai ter considerado a posição x e y. Então vamos salvar e vamos voltar aqui para a unity e agora a gente pode ver que a nossa nave está seguindo a posição do meu mouse.

Legal, então ela está seguindo meu mouse e como eu verifico se isso está funcionando no meu celular? Como a gente testa isso no celular? Eu falei para vocês que ela funciona, mas como eu testo?

A gente testa... eu posso pegar aqui o meu celular...eu tenho aqui com ele um aplicativo que é o Unity Remote, eu vou deixar um exercício para vocês entenderem como esse Unity Remote funciona, como vocês instalam e preparam a Unity para jogar o jogo no celular e na hora que eu dou o play aqui na tela, no meu celular, o jogo aparece.

Então eu vou jogar novamente e o jogo aparece. Se eu jogo aqui pelo celular, a gente pode ver que a nave está se movendo. Então a gente consegue dessa maneira testar nosso jogo no celular e verificar aqui na unity. Eu posso mexer ainda com o mouse, mas eu posso mexer pelo celular.

Então a gente vai deixar um exercício sobre como você instala esse Unity Remote e como você prepara a unity para testar as coisas no seu celular. E a gente vai continuar fazendo nosso jogo daqui a pouco.

Manipulando vetores - Seguindo um alvo

Bom, agora que a nossa nave já segue a posição do nosso mouse, então se a gente for jogar ela já está seguindo a posição do mouse ou a posição do dedo quando eu estava no celular, a gente tem que ter algum desafio nesse jogo.

A gente tem aqui nossos inimigos sendo gerados, essas bolinhas brancas aqui que estão do nosso lado. E se eu vier na cena a gente pode ver que eu tenho vários inimigos sendo gerados, mas eles ficam parados, eles não fazem nada.

Porque esses inimigos... se eu clicar aqui em um inimigo clone, que é um clone do Prefab quando a gente instancia ele vem com esse sufixo clone, ele não tem nenhum comportamento que faça ele seguir a nossa nave.

Então é isso que a gente vai fazer. E você deve estar reparando também que a gente tem três geradores aqui. Esses geradores estão nas laterais da minha tela e nas partes de cima, mas porque eu não tenho nenhum gerador aqui na parte de baixo? Porque a gente não fez isso?

Bom, essa foi uma escolha de game design. Quando a gente está com o celular jogando, a nossa mão geralmente está cobrindo a parte de baixo da tela e qualquer inimigo que viesse aqui de baixo iria deixar o jogo muito mais difícil porque a gente não iria conseguir ver ele vindo na nossa direção.

Então a gente preferiu não colocar nenhum gerador aqui embaixo. Agora que a gente já sabe disso, vamos fazer nosso comportamento de seguir a nave. Então a gente vai pegar um inimigo e eu vou ver como ele vai seguir a nossa nave.

Vamos sair do nosso jogo e vamos voltar aqui para o nosso slide. Então quais são as informações que a gente tem. Se a gente está criando um componente para o nosso inimigo. Então a gente vai criar algum script que vai dentro da classe inimiga, dentro daquele objeto inimigo.

Então, uma algumas informações que a gente tem são as posições desse inimigo. Esse inimigo vai ter um transform e a gente já tem a posição dele. Mas a gente também precisa saber a posição da nossa nave, já que é ela que a gente quer seguir. Então se a gente quer segui-la, uma informação fundamental para a gente é a posição dela.

E como a gente vai achar essa posição? Bom, se a minha nave é alguma coisa que eu vou precisar, eu posso criar uma propriedade dentro do meu componente, dentro do meu script, que guarde essa nave para mim, guarde essa posição.

E com isso eu vou ter uma propriedade alvo.transform.position. Então eu vou pegar algum alvo, vou buscar a posição dele e vou salvar aqui no meu script. Com isso a gente tem agora nossa posição do inimigo, a posição de quem está seguindo e o nosso alvo.

E você vê que eu desenhei ali como setas. Então a gente está partindo da nossa origem aqui...vamos pegar o apontador...da origem do nosso plano cartesiano, do nosso mundo e a gente está desenhando uma seta até a posição do inimigo e até a posição do nosso alvo.

E por que a gente fez isso como setas? Bom, porque são vetores. A própria unity usa a classe vector que representa um vetor matemático e aí é normal desenhar ele como uma seta partindo da origem do nosso mundo.

Então a gente tem esses dois vetores aqui que representam as posições. E aí, o que a gente quer é fazer com que o nosso inimigo saia da posição onde ele está e vá até a posição do nosso alvo. Então a gente quer criar esse novo vetor, essa nova seta que vem aqui e siga a nossa nave.

Mas como a gente vai fazer isso já que a gente só tem duas informações? Bom, a gente tem as duas informações que a gente precisa. Porque a gente tem as posições dos dois objetos que a gente quer. Então, se eu pegar a posição do meu inimigo e da minha nave e subtraí-las?

Então vamos falar que o meu alvo, a minha nave está na posição quarenta e cinco, sessenta. Uma posição aleatória. Não é a posição real dela. A gente já viu lá no último vídeo que a posição do nosso jogo mesmo está muito menor.

E vamos falar que a minha posição, a posição do inimigo está em cinquenta, trinta. Então é cinquenta em x e trinta em y. E aí, se eu quiser subtrair isso, como eu vou fazer? Bom, eu vou pegar, a posição do meu alvo e subtrair da minha posição. Então, para o eixo x eu vou ter quarenta e cinco menos cinquenta, que vai dar um resultado de menos cinco e para o eixo y eu vou ter sessenta menos trinta, que vai dar o resultado de trinta.

Bom, esse daqui é um novo vetor, uma nova posição no meu espaço. E como a gente pode desenhar isso? A gente pode desenhar com uma seta. E fazendo isso a gente vai ter essa seta resultado aqui. Então, essa seta resultado é o resultado da subtração do meu alvo pela posição do meu inimigo.

E a gente tem esse resultado. Mas ele está saindo lá da origem do nosso plano cartesiano e não é isso que eu quero. Eu gostaria que ele estivesse aqui onde está o nosso inimigo. Então como a gente pode fazer isso?

Como eu faço para mover esse resultado, esse vetor, lá para o inimigo, como se a gente estivesse desligando ele da origem para o inimigo? A gente pode tentar somar. Então, por enquanto, o nosso resultado está aqui e eu quero trazê-lo para cá.

E como que eu vou somar? Quem eu vou somar? Eu posso somar a posição do meu inimigo, que está aqui com a posição do meu resultado. Então, fazendo isso a gente vai ter de novo o nosso inimigo está na posição cinquenta trinta e o nosso resultado está na menos cinco, trinta.

Se eu fizer essa conta, a gente vai ter cinquenta mais menos cinco, então vai dar quarenta e cinco para o x e trinta mais trinta, ou seja, sessenta no y. E aí, essa conta, se a gente fizer de fato é a mesma coisa da gente deslocar esse vetor resultado para a ponta do vetor inimigo e depois andar nessa direção.

Então, se a gente depois pegar o inimigo e falar que a posição dele é igual à posição atual dele, mais o meu resultado, a gente vai estar andando da origem até a posição do inimigo e depois da posição do inimigo até o meu resultado na ponta.

Só que com isso a gente vai ter um problema. Porque na hora que eu faço essa operação, a posição do meu inimigo vai ser igual à posição da minha nave...e tudo bem, é isso que eu quero, mas eu estou teletransportando o meu inimigo. Porque eu estou fazendo isso em um instante. Em uma atualização do meu frame, em uma rodada do método update eu estou falando que a posição do meu inimigo é igual à posição da minha nave e não é isso que eu quero.

Eu quero que a posição do meu inimigo ande até a posição da nave e não que ela se tele transporte. Então, esse deslocamento aqui, que é aquele resultado que a gente achou, ele não pode ser tão grande assim. A gente tem que diminuir o quanto eu vou me deslocar.

E como a gente pode diminuir o tamanho de um vetor? Como a gente pode diminuir isso para ter uma velocidade constante? Porque é outra coisa que a gente precisa ter, uma velocidade constante. A gente quer conseguir manipular essa velocidade.

Então, como a gente faz isso para depois conseguirmos falar que o This.transform.position do meu inimigo vai ser mais igual, então vai ser ele mesmo igual a somado com o deslocamento? Como a gente vai fazer isso?

Bom, vamos pensar. Se eu tivesse um vetor de tamanho cem...então eu tenho aqui o nosso vetor que sai da origem e vai até o inimigo, vamos falar que ele tem tamanho cem. Então a distância da origem até ele é cem. E se eu pegar esse vetor de cem pixels e dividir por cem, no final eu vou ter um vetor de um pixel, de tamanho um.

Bom, legal, já deu uma diminuída. Então a gente vê que a divisão reduz o tamanho do nosso vetor. Mas, e se tivesse um vetor de trezentos pixels? Bom, se eu dividir ele por cem, eu vou ter no final um vetor de três pixels. Mas aí eu não vou ter aquela velocidade constante que eu quero.

Então, se eu pegar um vetor de trezentos pixels e dividir por trezentos, eu de novo vou ter um resultado de um pixel. E aí, se eu pegar um vetor de cinquenta e seis vírgula noventa e dois pixels e dividir por cinquenta e seis vírgula noventa e dois, eu vou ter um vetor de um pixel de novo.

Então a gente pode falar que qualquer vetor n dividido por n, o tamanho dele dividido por ele mesmo, vai ser igual ao vetor de tamanho um, uma unidade. A gente está usando pixel aqui, mas a gente pode usar a unidade que a gente quiser.

E aí, com isso, a gente pode reduzir o tamanho do nosso vetor de deslocamento de uma maneira constante. A gente sempre vai ter um vetor no final de tamanho um. E a gente consegue aplicar isso no nosso jogo.

Isso tem um nome. Quando a gente vai diminuir os vetores para eles terem tamanho um, diminuir ou aumentar...se eu tiver um vetor de tamanho zero ponto cinco e dividir por zero ponto cinco, eu ainda tenho um vetor de tamanho um. Isso chama normalização.

Então o nome dessa operação é normalização. Voltando ao nosso exemplo, eu tenho meu inimigo, tenho minha nave e vou pegar agora o vetor do deslocamento, só que eu vou normalizá-lo, então ele vai ser muito menor.

E aí, depois que eu normalizei ele, aí sim eu vou falar que a posição do meu inimigo é igual à posição atual dele mais esse deslocamento. E com isso ele vai andar um pouquinho para cima.

Como a gente faz isso em código? Vamos voltar na unity, vamos pegar nossos scripts do gameplay, criar um novo script, que vai ser o script de seguir, então, seguir, e a gente vai editar esse script. Vamos abrir o Visual Studio e o que a gente vai falar que a gente precisa?

Eu preciso de uma posição que representa esse alvo. Então eu vou falar que eu tenho uma propriedade serializada, então, SerializeField, private e quem guarda a posição para a gente é o transform, então eu vou chamar já direto o transform, Transform alvo.

Então eu vou ter esse alvo. E no meu update, o que a gente estava querendo fazer? Eu estava querendo pegar a posição desse alvo e subtrair da minha, porque assim a gente achava o vetor resultado do alvo, vetor de deslocamento.

Então eu vou falar que o meu vetor...uma variável deslocamento, vai ser igual à posição do meu alvo menos a minha. Então é a posição do meu destino menos a minha origem. Então é o alvo.position-this.transform.position então eu vou subtrair o meu destino da minha origem, a origem da posição que eu estou agora.

E esse vai ser meu deslocamento. Só que também a gente tem que normalizar. Esse deslocamento por enquanto está pegando aquela distância inteira. Eu quero diminuir essa distância. Então eu faço deslocamento vai ser igual ao deslocamento ponto normalized, é o normalização. Então a gente vai pegar esse vetor normalizado e vai falar que ele é igual a ele mesmo normalizado.

Então agora a gente já tem aquele vetor um. E no final, nossa última operação é falar que a minha posição é igual à minha posição atual mais esse deslocamento. Então this.transform.position vai ser mais igual, então eu vou somá-la ao deslocamento e vou atribuir mais igual ao deslocamento e vou salvar.

Então agora a gente tem o nosso script de seguir já pronto. Só que eu preciso definir quem é esse alvo. Então vamos salvar aqui, vamos voltar para a minha cena, vamos pegar o prefab do inimigo e vamos trazê-lo aqui para o nosso jogo.

Então aqui eu tenho o prefab do inimigo e vamos atribuir para ele o nosso script de seguir. E agora ele está com esse script aqui. E eu tenho nosso alvo e nosso alvo é o jogador, então eu vou pegar esse jogador e vou trazer para cá.

E aí com isso eu também preciso salvar meu prefab, então eu tenho o novo script, você pode ver que ele está em negrito porque ele é uma alteração que a gente fez em relação ao prefab, então a unity já avisa isso para a gente.

Eu vou pegar aqui e dar um apply, ou seja, eu vou salvar essas informações no prefab. A gente vai fazer isso e podemos ver no prefab do inimigo, se eu clicar, a gente pode ver aqui que eu tenho o componente Seguir.

Mas espera, meu alvo não está configurado aqui. O meu alvo está em branco. Bom, então vamos pegar o meu jogador e vamos trazer para cá. E a unity não está deixando. Por que a unity não está deixando eu pegar alguma coisa da cena, afinal o meu jogador está na cena, e colocá-lo como referência para o meu prefab, para o meu inimigo?

Porque o prefab é uma coisa que está dentro do projeto, ele não está dentro de uma cena específica. Diferente dessa instância do prefab que está aqui na cena, o prefab em si é uma coisa do projeto. E eu posso usá-lo em qualquer cena.

Ou seja, se eu pegasse esse inimigo e jogasse ele lá na cena de ranking ou na cena de menu e ele estivesse procurando uma referência para o meu jogador naquela cena, ele ia dar erro. Porque ele não consegue achar o jogador dentro da cena de menu ou dentro da cena de ranking.

Então a gente não consegue...essa é uma limitação dos prefabs, a gente não consegue referenciar dentro de um prefab alguma coisa que estiver em uma cena. A gente só consegue referenciar coisas que estão dentro dele mesmo.

Qual é o resultado disso? O resultado é que esse inimigo que está aqui na cena vai começar a seguir a minha nave, inclusive ele seguiu muito bem. Vamos voltar lá. Ele está seguindo ainda muito rápido. Por que ele está seguindo muito rápido?

A gente consegue vê-lo deslocando. Vamos lá no nosso script e a gente pode ver que eu estou deslocando ele, mas eu não estou levando em conta o tempo. A gente não está levando em conta quantos milissegundos passaram entre um frame e outro.

E a gente já viu isso, é o deltaTime. Então fazer vezes Time.deltaTime e vamos tirar isso daqui. Então agora nosso deslocamento deve estar menor. Vamos dar o play...e agora sim, ele está seguindo a minha nave, mas ele está...só ele está me seguindo, todos os outros não estão seguindo.

Se eu vier aqui dar o pause e voltar aqui, a gente pode ver que eu tenho um monte de erro de referência nula, porque eu estou tentando achar uma variável alvo que não existe. Todos os meus prefabs estão sendo criados sem essa propriedade de alvo.

Então, como eu faço agora para pegar o meu jogador e transformá-lo em um alvo para o inimigo que foi criado dinamicamente? Bom, quem cria dinamicamente os meus inimigos...vamos voltar para a minha cena, sair do modo de play...é nosso gerador de inimigos. Então, se o gerador de inimigos cria o inimigo, ele pode também ter uma referência de quem é o alvo daquele inimigo.

Ele pode injetar essa referência dentro do inimigo. E é isso que a gente vai fazer daqui a pouco.

Sobre o curso Unity Mobile parte 1: jogos para celular com persistência de dados

O curso Unity Mobile parte 1: jogos para celular com persistência de dados possui 213 minutos de vídeos, em um total de 48 atividades. Gostou? Conheça nossos outros cursos de Jogos em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Matemática para jogos
• Arquitetura de projetos
• Criando uma interface dinâmica
• Persistência de dados