Unity parte 2: iluminação, interface e boas práticas

Interface na Unity - Introdução

Meu nome é Henrique Morato e bem-vindos à segunda parte do curso de criação de um jogo de apocalipse zumbi com a Unity. Então, vou dar um play aqui para ver o que a gente vai fazer durante esse curso. De cara você já nota que esse jogo está um pouquinho mais escuro. Está com clima mais noturno, é porque a gente colocou iluminação no nosso jogo, então ficou um jogo meio terror, meio apocalipse zumbi, mostrando o que ele é, um climão mais legal.

A gente também tem essa barra de vida aqui que vai marcar a vida do nosso jogador e os nossos zumbis agora ficam vagando por aí. Para eles não parecerem tão espertos, indo para o jogador direto, eles ficam andando por aí até a gente chegar perto deles, e aí eles vêm nos perseguindo. Eles andam por aí, a gente chega perto e eles vêm nos perseguir.

Nosso jogo agora também tem sons. Então, se eu colocar o áudio aqui para vocês verem, a gente tem diversos sons e quando a gente morre para os nossos zumbis, a gente também tem uma nova tela de game over. Marcando quanto tempo eu sobrevivi e qual é o melhor tempo, e o botão para reiniciar o nosso jogo, cliquei aqui para iniciar.

O nosso cenário já está bem maior, a gente pode sair do estacionamento, vou voltar aqui e a gente já pode sair do estacionamento. A gente tem bem mais dinamismo agora que a gente tem mais locais para se esconder dos nossos zumbis. Então, a gente tem outros locais diferentes aqui para trabalhar, e a gente vai ver diversas boas práticas aqui dentro.

Então se você olhar a parte de scripts agora, a gente tem vários scripts novos que a gente criou durante o curso tanto como refatoração de scripts do curso antigo, ou seja, a gente refez alguns scripts para melhorar com boas práticas de programação para vocês verem realmente como é a produção de um jogo na prática com novos scripts, tantos scripts novos que a gente vai criar neste curso. A gente também focou em manter essas boas práticas.

A gente vai ver como trazer elementos de fora da Unity aqui para dentro também, para a gente poder utilizar aqui no nosso jogo. Também nesse curso a gente vai resolver diversos bugs que ficou do antigo curso, e se der algum bug na Unity eu vou deixar claro para vocês também aprenderem como podem solucionar os bugs que a gente te dá, enquanto vocês estão trabalhando no jogo de vocês também. Então, a gente tem muita coisa legal para ver e eu espero que vocês gostem desse novo curso.

Interface na Unity - Vida do Jogador

Vamos continuar a adicionar funcionalidades aqui no nosso jogo. Então, vou dar um play aqui para a gente ver onde a gente parou no curso passado. Nosso personagem está andando, olhando para todos os lados e atirando; e o zumbi persegue o personagem e quando ele ataca, eu dou game over.

O jogo já está bem dinâmico, só que tem uma coisa aqui que me incomoda bastante e já deve estar incomodando você também, que é o seguinte: não seria mais interessante jogador ter uma vida, por exemplo, e quando o zumbi ataca ele, ele perde um pouco de vida e aí à medida que essa vida acaba, aí sim o jogo dá game over? Porque quando eu clico aqui para reiniciar, aí eu vou, tento fugir, aí zumbi e me ataca, game over.

Então não tem dinamismo no nosso jogo. Não tem como eu aprender melhor a jogar esse jogo dessa forma. Então, vou tirar o play aqui, vamos fazer exatamente isso, vamos criar uma vida para o nosso jogador. Como que a gente vai fazer isso então? Clica no jogador, vai no script de, controla jogador, abre ele. E aí a gente tem que começar então a criar a vida.

Onde que a gente vai guardar a vida? Como que a gente vai fazer isso? Como que a gente vai guardar um valor para nossa vida? Vamos utilizar as variáveis que a gente já aprendeu no outro curso. Então, vou declarar uma variável aqui como public e aí pensa, a vida é o seguinte, a vida, quando você pensa em quantidade de vida você já pensa: Vai ser um número, mas vai ser um número quebrado, vai ser um número inteiro?

Então você tem que pensar: faz sentido a vida ter um valor tipo 49.5, ou faz mais sentido à vida ter um valor 49 e um valor 50? Faz mais sentido a vida ter valores inteiros, até facilita na hora de lidar com ela. Então, vamos colocar do tipo int, que é integer, números inteiros que não tem casas decimais, não tem números após a vírgula. Então, estou colocando a vida aqui como int, vou dar o nome de vida nessa variável e vou colocar um valor inicial aqui de 100, 100 de vida.

Salva isso aqui, vamos dar uma olhada aqui no espectro o que está acontecendo, a vida já está aqui, se eu der um play aqui o que vai acontecer quando o zumbi me bater? Nada, porque eu não mexi com a vida. A gente na verdade estava mexendo com a variável booleana que chamava vivo aqui, que é a variável que a gente está usando para fazer o game over.

Eu ainda não mexi com a vida. Eu tenho que começar a mexer com ela. Da forma que a gente fez o código, se eu vir aqui no inimigo, eu vou abrir aqui pelo lado, no visual studio, se você tiver usando um monodevelop você pode abrir pelo menu aqui na lateral também. No visual studio fica desse lado aqui, vou clicar duas para abrir o script do inimigo.

Do jeito que a gente fez a variável de vivo, a gente veio e falou: olha, quando zumbi atacar o jogador, esse método é chamado e aí eu faço a variável vivo ficar falsa. Só que a variável vivo é uma variável que está lá no jogador, e eu estou utilizando ela e trocando o valor dela aqui no inimigo. Nesse curso a gente vai focar em dar nome aos bois, falar: olha, isso aqui é do jogador e isso aqui é do inimigo.

A variável vivo na verdade ela é do jogador. Então, esse código não deveria estar aqui, ele deveria estar lá no jogador, que é exatamente o que a gente vai fazer com a nossa nova variável de vida, isso é conhecido como encapsulamento.

A gente está fechando funções, encapsulando, isso aqui é do jogador, o código do jogador tem que ficar no script do jogador, o código do inimigo, tem que ficar script do inimigo, se não daqui a pouco você está trocando coisas em diversos lugares e você não entende, onde que eu troquei o valor de vivo para fazer isso?

Aí você não entende onde que está esse código, onde que está essa troca de valor. Então, o código ele tem que ser escrito aqui, ele pode ser usado em outros locais mas ele tem que ser escrito aqui. Então, vamos fazer isso com a variável de vida. Só que como que a gente vai criar uma forma da gente vir aqui e trocar o valor da vida. Fazer o código no jogador e usar esse código lá no inimigo, como que a gente pode fazer isso?

No start? No update? No fixo de update? Ou a gente pode descer mais um pouco e criar um método nosso. Lembra quando a gente fez esse método aqui? Método é uma forma da gente organizar o nosso código, fazer várias linhas de comando acontecerem em sequência e a gente organizar pequenos comportamentos, que é exatamente o que eu vou fazer aqui.

Eu vou fazer um script, um método, que vai tirar a vida do meu jogador aqui no meu jogador, para eu utilizar ele lá no inimigo. Vamos começar a criar um método parecido com esse aqui de atacar o jogador, só que ele vai chamar "tomardano". Criei um método aqui do tipo void, que eu dei o nome "tomardano", método sempre tem que abrir e fechar parêntesis, abrir e fechar chaves.

Criei esse método aqui. Por que que é do tipo void void ? Void é um método que eu executo as linhas de código que eu colocar dentro dele, e não faço mais nada, ele executa e acabou. O nome dele, eu que dei esse nome, não era o nome da Unity, eu que dei, abre e fecha parêntesis, abre e fecha chaves. Aí eu vou começar a escrever códigos aqui dentro, aqui dentro um código que vai tirar a vida, que vai dar dano ao meu jogador, que vai tirar a vida dele.

Vou pegar a variável de vida e vou subtrair um valor , vamos supor 30. Então, criei o método "tomardano", peguei a vida e subtrai 30 e depois joguei o resultado dessa conta de volta no valor da vida, para isso que serve o menos igual, lembra dele? A gente utilizou bastante o mais igual no outro curso.

Então pega a vida, subtrai 30, deu 70, jogo o valor de volta com a variável vida, então a variável vida agora vale 70, para isso que serve o mnos igual. Vamos salvar isso aqui, vamos testar, o que que vai acontecer aqui agora. A variável vida mudou? Não, por quê? Porque a gente ainda não utilizou esse método, esse método a gente que fez, ele não é igual start, igual update, que a Unity define. Olha, o update roda uma vez por frame, o start roda no começo do jogo.

Esse método aqui, a gente tem que utilizar ele, a gente que vai dizer onde que a Unity tem que rodar esse método. E onde que a gente quer rodar esse método? no inimigo. Então, agora eu quero fazer o seguinte, eu quero cancelar essas três linhas, por quê? Porque se eu utilizar o "tomardano" aqui agora, nada vai acontecer, porque o jogo vai pausar, eu vou imprimir o game over, eu vou rodar a variável de vivo.

Vou pausar o jogo todo e não vou ver nada acontecendo, então o que eu vou fazer? Eu quero cancelar elas, então eu vou comentar essas linhas.

Para comentar uma linha é só colocar barra barra no começo da linha. O que é o comentário aqui? O comentário, ele faz com que essa linha seja ignorada pela Unity. Ela está aqui no código mas ela não vai acontecer, ela só está aqui para eu visualizar. Depois eu posso tirar o barra barra e utilizar essa linha mas por enquanto eu não quero que ela aconteça, e eu vou aqui no começo colocar, começar a utilizar esse método "tomardano".

Então eu quero utilizar o "tomardano" lá do jogador aqui no inimigo. Eu posso utilizar métodos de um script no outro? Posso, só que o código está no jogador, é isso que é importante, você dizer onde que o código está sendo criado. O código de "tomardano" no jogador tem que estar no jogador, mas o inimigo pode pegar e utilizar, chamar este método.

Como que a gente chama esse método, porque ele é diferente do start e do update, a gente que tem que chamar ele aqui, como que a gente chama um método em outro script? É simples, é como utilizar uma variável, eu venho aqui, puxo o componente de controla jogador e dou um ponto "tomardano". Só que ele não apareceu aqui, por que? Porque um método, igual uma variável, ele tem que ser público para a gente achar ele em um outro script.

Então vou vir aqui e vou agora ponto "tomardano", ponto e vírgula aqui. Salvo isso aqui, agora quando o meu inimigo ataca o meu jogador, eu estou chamando método de "tomardano". Salvo isso aqui, vamos dar um play e olha lá, toda vez que o meu inimigo ataca eu perco 30 de vida aqui.

Isso faz com que o nosso script vá ficar com dinamismo bem legal porque eu estou escrevendo códigos, encapsulando comportamentos nos seus lugares corretos . Agora falta a gente utilizar essa vida para gerar o game over.

Interface na Unity - Game Over pela Vida

Vamos fazer então game over acontecer pela nossa nova variável de vida? Vou abrir o código do controle inimigo e aí essas três linhas aqui são as linhas que davam o game over anteriormente.

O que eu vou fazer? Vou tirar o comentário dessas três linhas, estou tirando o barra barra aqui da frente e vou recortar elas aqui, vou dar um control x, então abri aqui o controle o inimigo, estou tirando do método do ataca jogador as três linhas do game over, e vou abrir o script de controlar jogador aqui.

No método de "tomardano", eu vou jogar essas três linhas. Como eu já estou aqui no meu código do jogador, eu não preciso vir aqui "jogador.getcomponent" controla o jogador, porque eu já estou no script de controle o jogador. Então, é só utilizar o texto e só utilizar o vivo.

Então pronto, é as mesmas três linhas de game over. Se eu salvar isso aqui, vamos ver o que que está acontecendo, salvei, vamos dar o play. Zumbi bateu, eu perdi novamente e eu recomeço. Por que eu perdi com um ataque só? Porque quando eu estou rodando o método de "tomardano" aqui no ataque o jogador, estou rodando o método "tomardano" e eu rodo ele, aí eu tiro vida e dou game over.

O que eu tenho que fazer aqui para dar o game over só quando a vida chegar a 0? Eu vou fazer um if aqui, eu vou testar isso. Se a vida for igual a zero, faz isso aqui, e vou jogar essas três linhas para dentro do if. Salvo isso aqui e vamos dar um play, vamos lá, vou clicar aqui no jogador para a gente ver a vida, a vida é 100, zumbi bateu 70, aí chegou em negativo e não deu game over. Por quê isso está acontecendo?

Porque que aqui eu fiz, olha, aqui a vida tem que ser exatamente 0. Só que se ele perde 30, de 30 em 30, ele vai perder 30, aí ele vai ficar com a vida 70, aí depois 40 , depois 10 e depois já vai para -20. Então, toda vez que você quiser fazer esse teste de, se a vida for 0, ao invés de testar se a vida for exatamente igual a zero, com igual igual, a gente testa se a vida é menor ou igual a zero.

Então se a nossa vida for menor ou igual a zero, aí sim, eu faço o nosso game over. Vamos dar o play aqui de novo, olha lá, vamos testar, chegou em menos 20 aqui, agora perdeu. Clica para Recomeçar. Já está funcionando. Só que eu preciso agora dessa variável de vivo aqui ou não precisa? Na verdade eu não preciso dela, por que? Porque a vida menor igual a zero aqui está fazendo exatamente isso aqui, então eu vou lá em cima e vou apagar a nossa antiga variável de vivo e vou salvar aqui.

Nosso código vai quebrar em alguns lugares, você já pode ver pelo pontinho vermelho aqui que ele quebrou em dois lugares. Vamos nesses lugares e aqui eu estou falando: se vivo for igual ou igual a falso, ou seja, se vivo for falso, o que eu vou fazer? Espera que eu aperte um botão e aí reinicia o jogo.

Então a invés de vivo ser falso eu vou testar se a vida é menor ou igual a 0. Vai acontecer a mesma coisa, só que eu estou utilizando uma nova variável numérica aqui. Se a vida for menor ou igual a zero, faz isso aqui, espera que ele clique com o botão e reinicia o nosso jogo. E essa linha aqui de baixo, eu não preciso mais, porque eu não estou utilizando mais a nossa variável de vivo.

Agora eu já estou dando game over pela variável vida, só que quando eu chamo aqui no ataca jogador, eu vim aqui e chamo o método "tomardano" e lá no jogador eu dou o dano nele que aqui eu estou dizendo que é 30.

Só que se eu quiser definir um dano lá no zumbi - porque dano é uma parte do zumbi - o zumbi é que está atacando o jogador, então não faz sentido eu dar o dano aqui no jogador, faz sentido eu definir o dano lá no zumbi e só dizer para o jogador, você tem que tomar 30 de dano aqui na sua vida.

Como que a gente pode fazer isso com os métodos.? A gente pode utilizar os parâmetros. A gente já utilizou parâmetros antes no script da bala aqui no on trigger enter, a gente utilizou parâmetro collider objeto de colisão. Só que esse parâmetro a Unity que definiu para a gente que quando o objeto colidir eu vou ter um objeto de colisão.

No objeto collide eu tenho o objeto com quem eu colidi. Aqui não, aqui a gente que criar o nosso parâmetro. E aí vocês já viram lá que o parâmetro em geral definido aqui, e aí vocês já viram lá que os parâmetros são definidos dentro de parênteses e eles são bem parecidos com a variável. Na verdade eles são variáveis que a gente vai utilizar somente dentro desse método.

Então vou criar um parâmetro aqui inteiro dano, porque inteiro? Porque a nossa vida é inteira então faz sentido eu tirar dela um valor inteiro, e vou dar um nome para esse parâmetro, o nome vai ser dano, então tem o parâmetro inteiro com o nome dano. Aí aqui dentro eu uso essa variável. Vou falar, olha, ao invés de passar 30 de dano, eu vou passar a variável dano.

Aí como é que eu sei qual que é o valor de dano aqui? Como que eu vou saber de onde vem o valor de dano? Quando eu chamo o método. Você vê aqui que no ataca jogador já deu até erro, ele fala , está faltando um parâmetro aqui. Como você passa o parâmetro? Você fala que dano é igual a 30, algo assim? Não, na verdade você só vai passar o número aqui.

Só vou passar o 30 e aí a Unity já é bem espertinha, ela já vai entender que você jogou 30 e eu tenho uma variável aqui que é inteira, que casa com esse 30, então o dano na verdade já é 30. Aí ele pega e faz tudo que você tava acontecendo antes, a vida menos o igual a 30 aqui, porque o dano agora vale 30.

Então, o código já é espertinho, ele já interpretou, você passou um número aqui, eu tenho um parâmetro que é o número, joga esse número nesse parâmetro e ele vai utilizar dentro do código. Só que, suponhamos que eu não quero sempre passar 30 de dano. Isso aqui vai estar funcionando se eu der um play, está tudo ok.

Mas vamos supor que eu quero fazer um dado meio variável algum tipo 20 a 30 de dano. Então, eu posso criar uma variável aqui dentro do método ataca jogador que vai guardar o dano que eu quero passar e eu vou usar o random para gerar um valor aleatório, eu não falei que eu vou utilizar um valor de 20 a 30? Vou utilizar a classe da Unity que chama random, que gera valores aleatórios para mim, entrando nela vou utilizar o método range onde eu passo um valor mínimo e um valor máximo, eu quero que a variável dedão receba um número aleatório de 20 a 30.

Então toda vez que eu rodar o método ataca jogador, ou seja, toda vez que o meu personagem atacar, eu vou vir aqui gerar um número aleatório de 20 a 30, guardar esse valor na variável de dano que agora é do meu inimigo e vou passar esse valor aqui. Apesar dessa variável aqui e essa aqui ter o mesmo valor, elas não são a mesma coisa, isso aqui podia ser qualquer coisa aqui, desde que esse aqui fosse igual, estaria tudo ok.

Porque aqui eu estou falando, olha, eu tenho uma variável que é o dano, passando ela como parâmetro aqui - aí eu falei, o código já é espertinho, ele vai saber, ah, o valor de dano é 25 - eu tenho um parâmetro que chama qualquer coisa aqui que recebe o número então joga nesse parâmetro o número 25 e faz o que tem que executar aqui dentro do nosso método.

Apesar delas aqui como eu tinha antes, terem o mesmo nome, elas não são a mesma variável. Dessa forma, o que eu estou falando? Olha, eu posso ter um dano aqui no zumbi, o zumbi gerou um dano para mim e eu estou passando esse dano para o jogador. Então, assim a gente pode comunicar e utilizar métodos de uma forma muito mais interessante. Aí a gente evita também uma outra prática bem legal quando a gente está fazendo o jogo, que é ter tudo dentro do update.

Aí eu não teria aqui, por exemplo, quando o zumbi ataca, que esperar um ataque no update e eu ter que dar um dano dentro update. eu estou usando essas chamadas de método justamente para não ter que ter tudo dentro do update, porque é uma boa prática você não utilizar tanto assim o update senão você vai ter muita coisa acontecendo a todo frame.

Aqui não, só quando zumbi ataca que eu vou lá e rodo o método de tomar dano. E aí agora se gente salvar tudo e testar, o que está acontecendo? Vamos dar um play aqui, vou clicar no jogador, a variável está tirando aqui, você viu que o valor está 15 aqui, já está gerando um número aleatório.

Vamos de novo, 100, zumbi me ataca, 77, gerou um número aleatório então de 20 a 30 aí. Aí ataca de novo 54, 32, 21. Aí roda o nosso game over, então agora a gente tem dinamismo bem maior e o código bem mais definido nessa parte de tirar a vida ou não do jogador.

Sobre o curso Unity parte 2: iluminação, interface e boas práticas

O curso Unity parte 2: iluminação, interface e boas práticas possui 266 minutos de vídeos, em um total de 67 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:

• Interface na Unity
• Audio, Cenário e Iluminação
• Boas práticas de código
• Melhorando o Zumbi e Gerador
• Salvando Melhor Resultado e Finalização