Transcrições
1. Introdução: Olá,
bem-vindo à minha aula sobre a criação de uma plataforma
intermediária, um jogo usando o motor
Unity Game. Nesta aula, criaremos do zero o jogo que você está
vendo agora. E, ao fazer isso, aprenda todos os fundamentos do
design e desenvolvimento de jogos, incluindo tudo o que você
precisa saber para criar um jogo exatamente como
esse sozinho Essa aula será dividida
em 18 vídeos, cada um abordando um tópico
diferente de design de jogos e uma nova etapa
no desenvolvimento de nossos jogos. Desde começar a
escrever código
até sistemas de partículas
e gerenciamento de áudio Ao fazer essa curta aula de
seis horas, você pode, em menos de um dia, aprender tudo o que
precisa saber para começar a desenvolver seus
próprios jogos e o Unity. Para obter mais informações sobre
essa classe e seu formato, confira o trailer da outra
aula abaixo. E nos vemos na
primeira aula. Felicidades.
2. 1. Configurando nossa cena: Olá, bem-vindo ao
primeiro vídeo deste curso
sobre a criação de uma
plataforma intermediária, um jogo usando Unity. Agora, antes de começar,
quero agradecer imensamente a
você por seu apoio
na matrícula neste curso ou aula É um suporte como
esse que
me permite continuar fazendo cursos. E eu realmente agradeço
que você tenha escolhido o meu. Agora, se você assistiu
ao roteiro, terá
visto basicamente uma visão geral do que esse curso envolverá e de todos
os diferentes vídeos e seções que
teremos Você também já deve ter visto o
jogo que vamos fazer quando
este curso terminar. Espero que este jogo pareça
bem legal e você esteja empolgado em poder
criar um jogo como esse Se parecer complicado, não se preocupe, na verdade não é
tão complicado. E você ficará bastante
surpreso com capacidade de
criar um jogo como esse. Não há muito tempo. Dito isso, obviamente,
criar um jogo leva um pouco de
tempo e não podemos fazer tudo em um único vídeo. Tudo o que
faremos nesta lição é apresentar
o editor Unity. E vamos
criar nossa cena para definir onde podemos
começar a criar nosso jogo. Agora, se você nunca
usou o Unity antes, sugiro que assista a
este vídeo inteiro. Se você já usou o
Unity um pouco e realmente entende
o layout do editor, pode pular
para um carimbo de data/hora ou colocar na tela
agora mesmo, para onde você pode pular,
porque quando começarmos a realmente usar o Unity para Mas se você nunca
usou o Unity antes, eu recomendo assistir os próximos minutos
enquanto eu explico exatamente o que
tudo é e como o editor funciona. Então,
vamos começar. Antes de começarmos, estou
usando o Unity versão 2023, 0.1 0.5 e tenho o layout
padrão ativado. Eu recomendo que você mude para
o mesmo layout que eu, para que você possa acompanhar ao longo do caminho. Você faz isso é
ir até o topo aqui, clicar em Janela
, descer até Layouts e escolher o padrão Ele deve recarregar sua cena
e fazer com que fique assim. Eu não gosto dessa pequena janela de navegação de
IA. Vou arrastar isso até lá e vai sumir. E então, basicamente, temos todo
o editor Unity
à nossa disposição. Vou começar
aqui no canto superior esquerdo. Esta é a nossa cena. E você pode ver que começamos com
uma cena chamada Sample Scene. Essa é uma cena padrão
que a Unity criou para nós. E se clicarmos
nessa pequena seta, podemos ver que tudo o que está na
cena agora é uma câmera. Agora, essa câmera é
basicamente o que gravará nosso jogo, e esses serão
basicamente os olhos do nosso jogador. Essa câmera é, na verdade, o que chamamos de objeto,
vou falar sobre isso mais tarde. Mas, basicamente, você pode pensar uma cena como uma espécie de nível em um jogo e pensar no objeto
como as coisas no nível. Um jogador, uma bala, uma moeda. Serão objetos e, em seguida, um nível
seria uma cena. No momento,
temos apenas um nível e nosso único objeto é
a câmera real. Mas você verá que, à medida que criamos nosso jogo e desenvolvemos
cada vez mais, vamos
preencher nossa cena e adicionar mais e mais coisas
basicamente nessa janela
de hierarquia Aqui é onde
você vai
criar objetos ou coisas em seu jogo, você
quer criar um personagem Se você quiser
mudar
praticamente alguma coisa em sua cena, você vai
fazer isso aqui em termos de adicionar ou
remover objetos. Então aqui, essa grande
janela no meio é na verdade, onde
você vai
editar o layout
da sua cena, ou onde as coisas estão, quão grandes elas são, todo esse tipo de coisa. É aí que você
vai fazer isso. Aqui, é como se
essa fosse sua paleta e essa fosse sua tela, se você quiser usar uma analogia de arte Mas, à medida que usamos cada vez mais o
editor Unity, isso se
tornará natural para você. Como usar essas duas coisas, especialmente bem
como o inspetor, que abordarei em um minuto Então, antes de
passar para o inspetor, a última coisa que quero
mencionar é essa janela de jogo E isso é basicamente
apenas um espaço de teste. Está apenas azul agora porque não temos
nada em nossa cena. Mas se eu colocasse algo dentro da nossa cena aqui, digamos que eu colocasse um
pequeno bloco dentro e fosse até a janela do jogo,
eu seria capaz de ver. E eu vou te mostrar
isso mais tarde, quando começarmos realmente a
montar nosso primeiro nível,
ou melhor, nossa cena. Continuando, temos
a janela do inspetor, e é basicamente
aqui que você visualizará as informações sobre
um objeto específico Assim, você pode ver que, se não
temos nenhum objeto selecionado, está em branco porque não
temos nada que estejamos
destacando Mas se clicarmos em um
objeto como nossa câmera, podemos ver todas as
informações sobre nosso objeto. E vou explicar isso à medida que
adicionamos nossas coisas à nossa cena. Mas basicamente esse
componente de transformação aqui, cada objeto tem, e é basicamente como você orienta seu objeto
dentro dessa cena Tem uma posição,
tem uma rotação, tem uma escala
que é um tamanho. E você pode alterar
todos esses valores. Obviamente, vamos
usar dois jogos D, então não
precisamos realmente do eixo z para a maioria dessas coisas. Mas é útil para rotação porque a rotação do eixo
z é, na verdade, dessa maneira Você pode ver que se
mudarmos assim, podemos realmente girá-lo Mas, independentemente disso, essa
transformação é onde editamos a posição,
nossa rotação e a escala de nossos objetos. Por baixo disso,
temos uma câmera. E você pode estar confuso
porque pensa, ok, bem, isso é uma
câmera. O que é isso? Na verdade, esse é um script
feito pela Unity. Para programar tudo isso para nós, o que o Unity efetivamente
faz é simplificar o processo de
desenvolvimento de jogos ao ter um monte de
código pré-escrito para nós na forma
dessas coisas que são
chamadas de componentes Então, isso pode
parecer muito difícil de entender,
mas confie em mim, isso
se tornará
natural à medida que você o usar
cada vez mais. Basicamente, essa câmera principal é um objeto que tem uma posição e uma rotação na escala. E então eles adicionaram esse script
pré-escrito do Unity chamado Camera, bem
como esse script de
ouvinte de áudio, qual você não
precisa se preocupar, mas é basicamente
parte da câmera E esses dois roteiros fazem com que
isso aja da maneira que funciona. E você pode adicionar outros scripts que são chamados de componentes. Ou você pode adicionar seus próprios scripts , chamados apenas de scripts. E, basicamente, será assim que
você programará seu jogo no Unity. Faremos com que um jogador se oponha. Então, digamos que queremos adicionar um sprite que seja como uma
imagem ou uma foto, basicamente como vamos
representar nosso jogador Vamos adicionar um componente de
renderização de sprites e isso nos permitirá
adicionar um pouco de arte ao nosso jogo Adicionaremos um componente do Box
Collider, que é basicamente como
vamos adicionar física Basicamente, todo o
Unity funciona criando esses objetos e adicionando scripts pré-escritos, que são componentes,
ou nossos próprios scripts. Certo, agora
temos a câmera, ela vem pré-carregada com
dois scripts pré-escritos. Mas, obviamente, podemos adicionar
outros scripts, se quisermos. E quando criarmos
nossos próprios objetos, mostrarei quais scripts
vamos adicionar. Se tudo isso parece um
pouco
confuso agora,
não se preocupe Isso se tornará muito,
muito simples à medida que
usarmos mais o Unity, mas basicamente essa é a essência de como o
inspetor de objetos Descendo
aqui até o final, esta é apenas a janela do projeto. É basicamente apenas uma
representação da pasta que seu programa está armazenado, ou melhor,
seu jogo está armazenado. Você pode ver que eu tenho uma
pasta aqui chamada Scenes, que está na minha pasta Assets. Mas eu tenho ativos
e pacotes,
e eles estão, na verdade,
armazenados no meu computador. Essa é apenas a
maneira do Unity de mostrar a você que, em vez de usar o Explorador de Arquivos, está no próprio Unity. Então, é exatamente a mesma coisa. É assim que
vamos importar
basicamente arquivos para nossos
jogos ou criar novos arquivos. Tudo está salvo aqui, e então isso realmente
vai para o seu computador. Isso meio que
mostra onde está. E, por fim, a última
coisa que temos aqui
é uma janela de console Agora, isso não é muito importante no momento porque ainda não
começamos a programar Mas é muito útil
porque é aqui que poderemos
imprimir coisas. Se você já programou antes,
estará familiarizado com o Hello World como o primeiro programa que você escreve em uma nova linguagem de
programação Que basicamente é
impresso na tela Hello World. Se você fosse escrever
isso no Unity, você o teria
impresso aqui. É aqui que você
receberá mensagens de erro avisos
sobre seu jogo Você receberá mensagens se
quiser registrar coisas. se você
quiser, por exemplo, criar um jogo em
que jogadores lutem entre si
e ainda não queira programar a saúde. Você só quer ver
se o código que diz, ok, esse player pressionou o
outro realmente funciona. Talvez você o imprimisse neste console e
dissesse que o jogador foi atingido. E é basicamente assim
que você vai usar isso. É muito bom para
depurar ou basicamente para gerar evidências de que seu
código
está funcionando em seus jogos Esse é um breve resumo de como o editor Unity funciona. Se isso pareceu um pouco
confuso, como eu disse, não se preocupe,
porque você entenderá isso como algo natural
à medida que o usarmos cada vez mais Mas espero que tenha
lhe dado uma ideia um pouco melhor de
como tudo funciona Agora, a última coisa que
vamos fazer neste vídeo, já que basicamente acabamos apresentar o motor e
falar sobre o curso, é começar a criar uma
cena muito simples para que
possamos começar com
nosso player no próximo episódio para criar uma cena. Vamos ver
nossa hierarquia agora mesmo. essa pequena estrela aqui Acho que vale a pena mencionar Isso significa que nossa
cena não está salva. Se eu clicar no controle S, você
pode ver que ele desaparece. Se você ver aquela
pequena estrela lá, talvez vá em frente
e salve seu programa. Controle S ou salve o arquivo. Só para garantir que você não
perca nada do seu progresso. Agora, queremos criar uma cena para que
nosso jogador possa
viver quando a fizermos. E ainda não
fizemos nossa jogada. Então, precisamos fazer, antes
de tudo, um minimapa. Primeiro, vou fazer
uma incrivelmente simples. Vou
clicar com o botão direito do mouse aqui porque quero
criar um novo objeto. E vou selecionar
dois sprites de objetos D e vou
escolher um quadrado O que isso realmente vai
fazer para mim
agora é apenas um pequeno quadrado. Todo quadrado é um objeto Unity. Tem uma transformação, então
tem uma posição,
sua rotação e sua escala,
exatamente como mencionamos. E tem um renderizador Sprite, que basicamente
permite que ele tenha o sprite quadrado que
está sendo exibido na Se eu clicar nele, eu posso
realmente movê-lo. Isso é o que vou usar como plataforma para meu
jogador existir. Então, eu vou fazer um
casal. Vou criar uma plataforma aqui em cima. Eu
vou fazer um lá embaixo. E vou fazer mais
um aqui em cima. Quando programo meu player, posso adicionar o salto e
ver se tudo funciona Agora, há algumas
coisas que precisamos
fazer para configurar esse mapa corretamente. Em primeiro lugar, não podemos ter uma plataforma que
seja apenas um quadrado, porque é muito
difícil pular nela Vamos começar clicando e arrastando para torná-lo maior Você pode fazer isso
neste modo aqui. Isso é basicamente
como o menu Ferramentas. Se você selecionar ferramentas diferentes, elas permitirão que você faça
coisas diferentes com os objetos. Por exemplo, este
está movendo-o de um lado para o outro. Este está girando. Obviamente, este vai
aumentá-lo e diminuí-lo. Esse aqui é
como uma combinação. É como você verá em um software de edição de
imagens, mas você
também pode fazer tudo isso nessa
janela de transformação aqui. E é isso que vou
fazer porque é um pouco mais exato e eu posso basicamente controlar
exatamente o quanto eu quero que essa coisa
gire ou escale Então, primeiro vou definir
minha rotação z para zero. Isso aqui basicamente
escolhe se
queremos que nossa escala seja
restringida para x e Y.
Então, se eu clicar nela, à medida que
eu aumento x, y e z, todas
elas sobem ou descem,
basicamente escalas Mas eu não quero isso. Vou me
certificar de que tem uma linha passando por ela e depois
vou reduzir y para baixo. Portanto, não é uma
plataforma muito longa. Super alto, desculpe. Vou escalar x
um pouco lá, eu diria que é uma
boa plataforma e vou
movê-la para lá. Agora, antes de criar
as outras plataformas, eu realmente preciso terminar de
fazer essa primeiro. No momento, tudo isso é
um objeto com um sprite. Então, na verdade, ainda não é
nada. É basicamente
como uma fotografia. Se agora eu quiser
adicionar um jogador, não
há nada que diga que,
quando eu chegar aqui, eu deveria parar de me mover ou
deveria fazer qualquer coisa. Na verdade, é como uma foto. Vou adicionar um novo componente que é um novo script
escrito pela Unity. E eu vou chamá-lo bid tut, ou melhor,
vou pesquisar,
box Alida, Tout. É assim
que se chama. E quando eu clico nele, você verá
que ele adiciona um novo pequeno script
ao meu objeto. Agora, meu objeto quadrado
aqui tem um renderizador de sprites
e um colisor de caixas E se você realmente ampliar
com o pergaminho, poderá ver um leve
contorno verde fora dessa coisa Se você selecioná-lo, obviamente não poderá
vê-lo se não o fizer, mas talvez você possa
vê-lo um pouco melhor se eu ativar esse motor aqui. Não sei se você pode
ver isso na minha tela, mas espero que na
sua você possa ver um leve contorno verde na
parte externa da plataforma,
que é o que é o O que um colisor de caixas
basicamente faz é dizer à Unity que essa coisa
é um objeto no espaço Se eu tiver
algo caindo e atingir o colisor de caixas, Unity dirá, ok,
pare de cair porque esse é um objeto real,
é uma coisa, certo? O Unity
colocará
automaticamente, no meu caso, meu box collider perfeitamente
ao redor da minha plataforma Mas se eu quisesse mudar isso, eu poderia clicar nessa
coisa aqui, que diz Edit Collider E então você pode ver que agora posso basicamente ter o controle lá. Você pode ver a caixa
verde. Eu tenho controle sobre o tamanho que
quero da minha torta de coliders Se eu quisesse que fosse
assim, se um jogador estivesse caindo, ele pararia ali em vez de cair
até o fim. Na verdade, eu não quero isso,
então vou clicar no controle Z e
colocá-lo de volta
onde estava. Mas é assim que você
edita seu box collider. Agora, antes de continuarmos,
uma outra coisa que
devo mencionar é que esse e todos os outros tipos de
rótulos que você vê aqui são como
atributos do script. Você pode pensar
neles como variáveis, mas o que eles realmente
são são atributos
do script que basicamente permitem que você mude a forma como ele funciona. Obviamente,
esse roteiro é muito geral, esse também. Você não pode ter um
planador de caixa que diga, ok, faça um planador de caixa com
essas dimensões exatas porque queremos
poder personalizá-lo Na verdade, o Unity está incorporado a
tudo isso para nós. modo geral,
quando os adicionarmos direi o
que mudar. Portanto, não saia por aí se
enchendo deles, porque eles mudam isso
drasticamente A menos que, obviamente,
você saiba o que está fazendo ou queira fazer algo um pouco
diferente do que eu estou fazendo, então, por favor. Mas agora, por
exemplo, nosso box glider tem todas as configurações padrão que
são, na verdade, perfeitas para nós Este, por exemplo,
é um gatilho. Se eu fosse selecionar
isso, isso significa que esse planador não influenciará
realmente a física Em vez disso, enviará um sinal e dirá,
ok, fui atingido. Poderíamos usar isso para algo como uma bala ou como um inimigo Onde queremos, talvez
o jogador consiga passar por eles. Mas queremos saber
quando os escolhemos
para essa plataforma. No entanto, definitivamente não
queremos isso porque queremos que o jogador
pare ao pousar nele. Vamos deixar tudo isso por enquanto. Além da renderização do sprite, todas
elas são realmente boas
como configurações padrão E então o que
vou fazer, porque
não tenho vontade de fazer
tudo isso de novo, é dizer controle
C e controle V e copiar nossa
plataforma quadrada e movê-la
para baixo. Eu disse que ia
ter um aqui em cima e talvez deixe-me
torná-lo um pouco mais curto e depois vou fazer isso mais uma
vez e vou movê-lo
para cá
para talvez um pouco mais baixo. Eu vou fazer este mais
curto também e
movê-lo para lá. Agora fizemos três
objetos aqui. Nós os chamamos de
quadrado um e quadrado dois, que
não são nomes muito bons. Vamos renomeá-los em um minuto, mas basicamente esse
será o início do nosso jogo Esses são os três
objetos
que criamos e adicionaremos
um jogador na próxima lição. E poderemos pular sobre esses objetos
para mostrar que nosso movimento
e tudo funcionam. Mas estou me adiantando. Basicamente, esse é o
começo do nosso jogo. Temos três plataformas, e todas elas têm aceleradores de caixas para mostrar que são
objetos no espaço Por último, vou dar um
nome a eles. Vou nomear este andar como um. Vou chamar isso de um andar e dois. Vou chamar isso de um andar três. A última coisa que eu
realmente vou fazer é organizar
nossa cena um pouco. Primeiro, vou salvar porque posso ver
esses ícones lá. Então eu vou dizer, ok, eu realmente não
quero que tudo isso esteja no mesmo nível
da câmera principal. Quero criar uma pasta,
você sabe como no Windows, no Explorador de Arquivos ou
no Mac, seja o que for, você armazenaria
seus arquivos em pastas. Você não teria simplesmente todos os seus arquivos
no mesmo lugar. A mesma coisa
aqui. Não quero que esses três objetos estejam no mesmo nível das minhas câmeras. Vou
clicar com o botão direito do mouse e
dizer criar, vazio, vazio. Tecnicamente, é
um objeto vazio. Obviamente, tem uma
transformação porque todo objeto precisa
ter uma posição. Mas você pode
usá-lo como uma pasta, basicamente
como uma pasta vazia que você
usa para armazenar outras pastas. É assim que você pode pensar nisso. Vou nomear
esse armazenamento. Vou colocar meus três
andares dentro do depósito mantendo
pressionada a tecla Shift selecionando-os e
depois arrastando-os Você pode ver agora que eles
estão armazenados dentro dele. Agora eu tenho uma cena um pouco
mais limpa e ela faz com que pareça
um pouco melhor. Se eu quiser ver
onde estão minhas falhas, basta clicar nesta
pequena seta e
posso ver que todas as três
estão lá Espero que tenha sido uma
boa introdução a este curso e à forma como ele
será estruturado Espero que você tenha
conseguido
acompanhar e criar plataformas de
três níveis. Eles não precisam
ser exatamente iguais, mas obviamente
têm apenas três plataformas. E vamos começar
no próximo vídeo com a adição do nosso
personagem de jogador. Obrigada.
3. 2. Criando nosso personagem: Olá, e bem-vindo ao
segundo vídeo do meu curso. Agora, no último
vídeo, apresentamos o editor Unity e
explicamos basicamente o que todas essas janelas
diferentes fazem. Depois de terminarmos
com isso, configuramos essa cena básica para
começarmos a criar nosso jogo. Agora, tudo o que temos agora em nossa cena é essa câmera
principal e o objeto de armazenamento que tem nossas três peças
de falha dentro dela Mas isso não é um bom
jogo no momento, na verdade, se não fizemos da última vez. Mas eu vou
te mostrar agora que
não há muita coisa
empolgante que aconteça. Temos apenas três objetos que, na verdade, são
apenas três sprites, então eles são como três
fotos com colisores Então, eles são objetos no espaço, mas não são muito mais do que isso. Se quisermos fazer
um jogo um pouco mais interessante do que
esse, o que
fazemos, teremos que
adicionar outro objeto
e, na verdade, um
monte de objetos a mais. Mas o primeiro outro
objeto
que vamos adicionar será nosso jogador. Porque se você não
tem um jogador, você realmente não tem um jogo. Obviamente, vamos
querer adicionar nosso player. E então podemos começar a adicionar nossos outros objetos
, nossos inimigos e tudo mais. Isso
faz de um jogo um jogo. Mas não vamos nos
precipitar demais. Basicamente, o que precisamos
fazer neste vídeo é adicionar
nosso objeto player. Vamos adicionar
nosso objeto de jogador exatamente
da mesma forma que
criamos esses objetos de chão. Vamos clicar com o
botão direito do mouse aqui. Vamos criar dois,
o objeto e, na verdade, vamos
criar um sprite quadrado Agora você pode ver aqui,
se eu criar meu sprite, eu tenho esse bloco branco
que é nosso jogador Por enquanto, isso é obviamente
um espaço reservado, porque adicionaremos sprites
e arte ao nosso jogo Mas, por enquanto,
terá que fazer isso. Vou clicar nele
duas vezes e chamá-lo de Player. Ele também pode fazer isso
clicando em Renomear. momento, tenho
meu objeto de jogador, mas não há nada
que realmente o
diferencie
desses três objetos Na verdade, eles são
praticamente iguais. Eles são apenas quadrados que
foram escalados de forma diferente. A primeira coisa
que vou fazer é mudar o tamanho do meu player. Vou fazer com que seja
0,65 em vez de um, e isso vai
torná-lo um pouco menor Você verá mais tarde, quando
adicionarmos sprites ao nosso jogo, poderemos ver exatamente o tamanho de
tudo, porque
vou usar arte em pixels Você não precisa usar pixel art. Mas, obviamente, se você
quiser fazer
exatamente o mesmo jogo que eu, obviamente
usará os mesmos sprites Obviamente, vou vinculá-los a cada vídeo
em que os usamos, para que você possa usar os
mesmos que eu. Mas, basicamente, por enquanto,
estou me precipitando. Tudo o que temos é um quadrado e, portanto, podemos escolher
o tamanho que quisermos. Agora, abaixo disso, também temos um
componente de renderização de sprite E você pode ver exatamente como
esses três objetos do chão, essa é a única coisa
adicionada a esse objeto. É basicamente como
um objeto vazio com um sprite com algo para
mostrar que o objeto está lá A primeira coisa que vou
fazer é
mudar essa cor
aqui para amarelo. Só para que eu possa ver que é diferente do
resto da minha cena. Na verdade, podemos ver
isso. Agora podemos ver que nosso piso é branco
e nosso jogador é amarelo. Só para dar ao jogador um
pouco de diferenciação, se eu clicar em jogar agora, não vai
ser muito diferente de quando
jogávamos antes Na verdade, vai
parecer
praticamente o mesmo. Nada
vai se mover. E esse jogador não consegue interagir com o
ambiente de forma alguma, que é uma das coisas de que
precisamos para nosso jogo. Então, vamos
começar adicionando exatamente
o mesmo componente que
fizemos a eles para que eles saibam que esse também
é um objeto no espaço e também
precisa ser colidido Vamos adicionar outro
box collider two D. Como eu disse da última vez, você pode praticamente deixar tudo exatamente como está Obviamente, se você
quiser mudar isso, você pode. Mas eu não vou
fazer isso. Então, vou clicar em
Controle Z e
movê-lo de volta para o que estava certo. Agora temos um colisor de caixas. Agora, você pode esperar que, se
clicarmos em Jogar e movermos nosso jogador até onde estão
os outros blocos, eu não
consiga ultrapassá-lo, mas esse não é
realmente o caso e é por dois motivos principais. Um deles, que é
como um submotivo,
é porque o motor de
física do Unity não foi
realmente construído para
detectar colisões, como detectar
movimentos como esse,
porque isso não é algo que o jogador
jamais seria capaz Na verdade, estou editando minha cena
agora e estou dizendo,
ok, o editor Unity agora
detecta uma colisão E mesmo que o Unity esteja realmente detectando
essa colisão, ele realmente não pode fazer
nada a respeito Porque eu
realmente não segui as leis de física da
Unity para colocar minha coisa lá, então ela
realmente não sabe o que fazer. Essa é uma espécie de subrazão. Mas a principal
razão pela qual o Unity não é realmente capaz de mostrar
que estamos bloqueando isso ou mostrar que aquela colisão está acontecendo é porque
não adicionamos o que é chamado
de corpo rígido a esse jogador E um corpo rígido é
basicamente como um componente físico
embutido que
generaliza cada aspecto da física clássica que
você precisa para um objeto Então, ele o torna
capaz de acelerar, faz com que seja capaz de cair de
acordo com a gravidade, ele o torna capaz de se mover. No momento, o Unity realmente não tem nenhuma maneira de
mover esse objeto, mesmo por meio de código ou qualquer outra coisa. Você poderia fazer isso talvez
movendo a transformação, mas não há uma
maneira confiável de o Unity realmente
implementar física, movimento
e forças nesse objeto. Para adicionar isso, precisamos apenas
adicionar mais um componente, que eu mencionei é
o corpo rígido dois D. Isso é como
um componente geral, como eu disse, que basicamente
adiciona física a esse objeto Essa é uma
maneira bastante básica de dizer isso, mas é o que ele faz. Vou
prosseguir e realmente mudar esse
arrasto angular para zero. E vou clicar
aqui nas restrições
e congelar
a rotação de Z.
Agora, e congelar
a rotação de Z. pode
parecer que eu fiz muitas coisas e
acabei de apresentá-las, mas vou
explicar melhor E você se familiarizará
mais com esses objetos e
exatamente com o que eles fazem, ou melhor, com esses componentes,
à medida que avançamos no curso. Portanto, não se preocupe muito com cada uma
dessas pequenas coisas, mas basicamente o que esse objeto
faz é adicionar física. Agora, a forma como funciona
não é de grande importância, especialmente para este curso, porque ele está incorporado ao Unity. Esse é basicamente um script
muito complicado que a Unity escreveu para nós. E essas são todas as
variáveis que podemos mudar. Então, podemos mudar
a escala de gravidade, podemos mudar o arrasto, eu defino
isso como zero só porque não é de uma importância
imensa, mas você não precisa
mudar isso para zero Você pode meio que ficar com
isso, isso realmente não vai
fazer diferença. E então a única
outra coisa que mudei foi a rotação do eixo Z. E o que isso
vai fazer é que, se eu não
tivesse mudado isso e
colocado meu objeto ali, quando eu clicar no jogo,
ele cairia E então ele realmente
vai girar dessa maneira, assim como faria na vida real. O que não é algo
que eu quero para o meu jogo. E eu realmente não recomendo que você o use para plataformas de jogos porque, a menos que você esteja usando quadrados, ele não
parece muito bom Vou usar arte em pixels, então não vai
ficar nem um pouco boa. Mas depois de adicionar esse componente
rígido do corpo, congelar a rotação no eixo Z e definir o arrasto angular para
zero, se quiser Essa é praticamente toda
a configuração que precisamos fazer. E agora vamos
ter um objeto em nosso jogo que pode realmente
obedecer às leis da física Se clicarmos em Reproduzir, podemos ver
que nosso objeto
cairá e parará no minuto pousarmos em outro colisor, que é exatamente o que queremos E podemos realmente voltar
e mover isso de volta para cima. E podemos ver que funciona exatamente como esperávamos. Obviamente, não
seremos capazes lançar nosso objeto ou
algo parecido. E isso é mais ou menos pelo
motivo secundário mencionei anteriormente: tecnicamente,
esse não é o mecanismo de física do
Unity no player Sou eu editando meu jogo e depois
dizendo, ok, Unity Takeover Portanto, o Unity não
tem informações sobre a
rapidez com que eu o
lancei ou se fiz algo parecido Acabei de deixar meu jogador na parte inferior do mapa. Então, eu vou
movê-lo de volta para cima. Vamos movê-lo por dez minutos desse
jeito. Perdi novamente. Veja o que realmente está
acontecendo agora é o jogador está se movendo tão rápido que não consegue
mais detectar colisões O que, na verdade, me leva a
outro ponto importante. Se você acha que
terá uma plataforma com colisões incrivelmente
rápidas, convém
mudar isso para contínuo E eu basicamente serei capaz de
ilustrar o que isso faz. Agora, se eu fizer exatamente a mesma
coisa que fiz antes, faço com que o jogador
caia e ganhe velocidade,
obviamente, pois ele acelera cada vez mais rápido
em direção ao solo Vou esperar um pouco,
vou mudar isso para cinco. Não, para definir isso como zero. Você pode ver que eu realmente
consegui parar neste momento. Então isso não foi
totalmente intencional. Mas esse é, na verdade, um
bom momento
de ensino sobre como o corpo
rígido da unidade funciona Portanto, cabe a você decidir
se deseja ativar essa configuração. que é um pouco mais
intensivo Creio que é um pouco mais
intensivo fazer uma verificação
contínua. Mas, na verdade, geralmente é algo que eu gosto de adicionar
aos meus jogos. Então, em resumo, basicamente
acabamos de adicionar nosso objeto Player, temos uma
renderização de sprite aqui Adicionamos um colisor para dizer ao Unity que é um objeto no espaço Também temos nosso
corpo rígido aqui, qual alteramos o
arrasto angular Definimos a detecção de
colisão como contínua por causa
daquela coisa que descobrimos acidentalmente e
congelamos a E essas são, na verdade, todas
as configurações que
precisaremos fazer para
começar a criar nosso player. No momento,
temos basicamente uma plataforma, um jogo, mas você não pode realmente
jogá-lo, você pode simplesmente cair. Então, o que vamos
começar
no próximo episódio é basicamente adicionar nosso script de movimento para
tornar nosso jogador capaz de pular e
cair e se mover para a esquerda e direita e
tudo mais que precisaremos. Então, vamos
começar a programar no próximo episódio, mas agora, você
deve ter sua cena configurada
exatamente como a minha
4. 3. Adicionando movimento de jogador: Olá, e bem-vindo de
volta à Unity. Agora, esta é a terceira
lição do nosso curso. Até agora, o que adicionamos é
um objeto de jogador que pode cair e colidir com três objetos no chão que
criamos antes disso Mas ainda não
temos um jogo. O que realmente temos é uma demonstração de
física
incrivelmente simples. Cai e para aí. Mas isso não é o
mais interessante. E para tornar isso mais interessante, o que vamos adicionar é um script que
basicamente permitirá que o jogador se mova e
basicamente jogue nosso jogo. Porque sem um roteiro,
não temos realmente um jogo porque
realmente não temos nenhuma maneira de influenciar o resultado, o que é o ponto principal Então, para começar, primeiro
vamos acessar essa pasta
Assets aqui. E, dependendo se
você já
transferiu arquivos, se estiver
acompanhando, você deve se parecer exatamente com
o meu, com apenas uma pasta de
cenas. E dentro da cena, temos nossa cena aqui, que
é chamada de cena de amostra. Agora vou voltar para
a pasta Assets e,
na verdade, vou escrever clicar e clicar em Criar nova
pasta e chamá-la de scripts. E é aqui
que vou colocar cada pedaço de código
que escrevo para este projeto. Você não precisa
segui-lo exatamente como eu. É assim que eu gosto de ordenar meus scripts e minha
pasta para o meu jogo, então vou clicar
duas vezes nela. E agora vou começar
a fazer meu primeiro script
C Sharp. Agora, se você nunca
programou em C Sharp antes
, obviamente
você vai querer assistir
a esse vídeo inteiro Se você codificou em C sharp e
não precisa de tanta ajuda
, pode escrever
seu próprio roteiro de movimento Mas vou
escrever um texto bem simples apenas para
apresentar a ideia. E então podemos
mudá-lo à medida que avançamos. Vou escrever Click
e vou
criar um script nítido em C e vou
chamá-lo de movimento do jogador. No minuto em que eu fizer isso,
podemos realmente clicar
no script e
visualizá-lo em um modo de visualização. Aqui, podemos ver agora que
temos uma classe
que foi feita para nós e temos dois vazios
que são como métodos Vou explicar tudo isso.
Você realmente não precisa se preocupar
muito com a terminologia de codificação, mas basicamente siga E você deve se
familiarizar muito mais com C sharp à medida
que codificamos cada vez mais. Mas vou explicar
tudo, então não se preocupe. Vamos
clicar duas vezes nele para abri-lo. Vou usar o
Visual Studio como meu IDE. O que é um IDE é que você pode pensar nele
como um editor de código, como se você usasse o Word ou
o Google Docs para editar ensaios Isso é o que você
usou para editar o código. Você pode usar o
que quiser, mas eu recomendo o
Visual Studio. Estou usando uma versão bastante antiga, mas praticamente qualquer uma delas é muito boa,
especialmente para Unity. Imediatamente, abra-o, pode parecer um pouco confuso, como o que são todas
essas palavras e o que significam as diferentes
cores? Como eu disse, não se preocupe
muito com tudo até agora. Vou explicar todas
as coisas importantes que temos
no topo. Usando. Sem entrar
muito na terminologia do que isso
realmente significa, pense como se estivéssemos dizendo unidade quais partes da
unidade queremos usar Então, se quiséssemos usar algo
baseado na interface do usuário, teríamos que adicionar uma nova linha
aqui que diz o
uso do Unity Engine. Basicamente, isso está nos dizendo, ok, essas são as partes
do Unity que eu preciso. Na verdade, esses scripts padrão
funcionarão muito bem para a maioria dos nossos scripts que
vamos escrever. E se precisarmos
adicionar um diferente, obviamente
vou
te contar enquanto escrevo o roteiro, porque você escreverá
junto comigo, então não se preocupe muito com
isso. Aqui embaixo está
nossa aula pública. Novamente, não se preocupe
muito com o que exatamente é uma
aula. Mas você pode
pensar nisso como um contêiner para todo o nosso código. Tudo isso é
terminologia de codificação , que, se
você realmente quiser, pode pesquisar
na Internet e
entender exatamente quais são as definições de tudo isso Mas eu não vou
falar
muito sobre isso neste curso
porque isso realmente
não é tão importante
para o desenvolvimento do Unity. Na verdade,
vamos
nos concentrar em mais como desenvolver jogos. E você realmente não
precisa ser
capaz de definir esses conceitos
diferentes, você não precisa apenas saber
como codificar. Obviamente, quanto mais você codificar, mais você descobrirá e mais
aprenderá sobre eles. Mas, por enquanto, não se preocupe
muito com eles
, porque pode ser muito intimidante
ter
que aprender todo esse tipo de coisa
de cor agora E isso realmente não é
tão importante para nós. Dito isso, há
algumas coisas que precisam ser revisadas. Primeiro de tudo, isso é um comentário. E um comentário é basicamente como um trecho de código que na verdade
não é código. É como uma linha para dizer a
alguém que está lendo o código, o
que é o que
essas duas barras indicam essas duas barras antes. Se você colocar assim,
você pode escrever
o que quiser e
o IDE ou o editor
saberão disso você pode escrever
o que quiser e o IDE ou o editor
saberão Esse não é um código que
precisa ser executado. Na verdade, não
precisa ser decifrado. O que essa afirmação significa? É só um comentário. Esses são
comentários
escritos pela Unity. Para explicarmos o que são esses
dois vazios diferentes, diz que start
é chamado antes do primeiro quadro, update e
update são chamados uma vez por quadro Agora, esses dois vazios,
a última coisa que quero mencionar são métodos semelhantes Você pode pensar em
métodos como seções do nosso código que podemos
chamar em determinados momentos. No momento,
carregamos nosso código. Este é o nosso grande programa.
Esta é uma seção do nosso código que vamos
chamar antes da
primeira atualização do quadro. Esta é uma seção do
nosso código que
chamaremos de
cada quadro. E, obviamente,
tudo isso é feito pela Unity para nós quando
criamos nossos próprios métodos. Mais tarde, teremos que
escolher quando ligar para eles. Mas esses são os dois
métodos a partir dos quais vamos
basicamente construir todo o nosso código. Obviamente, o
método start será executado no minuto em que esse código
for executado pelo Unity, antes que o primeiro quadro seja reproduzido, podemos escrever algumas
coisas aqui e dizer, ok, isso, faça isso, faça
isso e o Unity fará isso. E esse código aqui será executado em
cada quadro, cada quadro.
Isso vai se chamar. Se eu disser imprima um número, cada quadro, ele
imprimirá esse número. E se eu disser imprima
um número aqui, ele o imprimirá uma vez
antes do início do jogo, e então não
funcionará mais. Isso deve ser bem rápido e talvez um pouco
confuso para você, mas espero que os
conceitos básicos façam sentido E, como eu disse,
não se
preocupe muito com os detalhes
ao acompanhar, você os
entenderá cada vez mais E se parecer um pouco
intimidante no começo, não se
preocupe, vai
ficar mais fácil depois Mas em termos de
começar com a codificação real, vamos começar
indo até o topo e criando o que
é chamado de variável Agora, uma variável é como um espaço de
armazenamento em código, então vamos
criar uma variável, vamos chamá-la de velocidade de movimento. E então esse é um espaço
de armazenamento em toda vez que eu quiser acessar
a velocidade com que o jogador deve se mover, vou dar uma olhada
nessa variável e ver, ok, o que está armazenado aqui. Você tem diferentes
tipos de variáveis. Vou abordar
algumas brevemente e agora vamos começar a
programar de verdade Mas, basicamente, existem
números inteiros que são números. Existem sequências de caracteres que
são como palavras ou texto. Também existem caracteres
que são letras únicas. E então você tem booleanos
que são verdadeiros ou falsos. Por fim, você tem flutuadores que são basicamente
como decimais, então não se preocupe com
muitos deles. No momento, como
eu disse, tudo
isso vai
acontecer de forma mais natural. Mas eu só queria te
dar uma visão geral básica
de todas as noções básicas de
codificação que você precisará para esta lição Para começar, vamos
criar nossa primeira variável
e vamos
chamá-la de pública, o que basicamente significa que
ela pode ser acessada por qualquer coisa em
todo esse script flutuante E vamos
chamar isso de velocidade do jogador. Em seguida, vamos adicionar
um ponto e vírgula no final. Vamos
usar essa
velocidade pública do player para determinar a
velocidade com que nosso player deve ir. Vamos criar um novo. Flutuador
público, outro carro alegórico público, vamos
chamá-lo de altura do salto Agora, basicamente, o que dissemos
ao IDE, ou melhor dizendo à Unity, é que queremos um público para que ele possa ser acessado por
qualquer coisa no script. não se preocupe
muito com eles no momento, mas apenas copie
enquanto eu os faço flutuar, que significa que é
um número decimal e é assim que se chama A razão pela qual estamos realmente
usando o público é para que possamos acessá-lo nos editores
do Unity Se eu prosseguir e arrastar esse
script para um objeto, poderei ver isso
no editor Unity, é por isso
que estou usando public. Mas acompanhe por enquanto e faça exatamente o que estou fazendo. E tudo deve fazer
sentido porque, como eu disse, mesmo que pareça um
pouco intimidante no começo, vai
ficar muito mais fácil Agora, antes de prosseguir, há mais
algumas coisas que preciso
adicionar no topo aqui. Os quatro primeiros serão uma referência aos componentes que
adicionamos ao nosso objeto. Adicionamos um corpo rígido que
basicamente diz, ok, obedeça às leis da física, mas precisamos
basicamente ser capazes de
acessar esse
corpo rígido em Vou criar um corpo rígido
público
dois D e chamá-lo de RB Isso basicamente
vai dizer, ok, agora eu tenho uma referência a
esse corpo rígido para que
eu possa efetuá-lo A forma como vamos
criar movimento é mudar a
velocidade do meu corpo Então, eu vou dizer que quando
eu clicar nessa tecla, faça-a se mover tão rápido
nessa direção. Para fazer isso, obviamente
precisamos de uma referência ao
componente físico do meu objeto, que é esse corpo rígido Depois de fazer isso, tenho praticamente
tudo o que
preciso para começar a codificar meu script de movimento
muito básico Vou acrescentar mais uma
coisa abaixo disso,
um ouro público, que
significa verdadeiro ou falso É chamado de touro em C afiado, e vamos
chamá-lo de aterrado Isso basicamente vai nos
dizer se estamos
no chão ou não? Agora, no minuto em que você cria essas quatro variáveis e essa referência a esse
componente aqui, temos tudo o que precisamos
para começar a codificar nosso jogo A primeira coisa
que vou fazer é criar um novo vazio E esse vazio
será chamado de atualização fixa. Agora, na verdade, esse é
outro vazio criado automaticamente
para nós pela Unity É como uma atualização, acabou de
ser corrigido. A atualização não é baseada na
velocidade do seu computador. A atualização é chamada de
cada quadro, certo? Obviamente, se você
tiver um computador rápido, ele será
chamado muito mais rápido. Se você tiver um
computador lento, a atualização fixa
é chamada em um intervalo
muito, muito curto. Então, por mais que a
atualização esteja na maioria dos computadores, obviamente, você tem um computador
super rápido, pode ser um pouco mais lento Se você tem um computador muito
lento, ele pode ser um pouco mais rápido. Mas é um bom
método para colocar física, lógica e outras coisas do
tipo em seu jogo. Porque você não quer
que alguém que tenha um computador mais rápido possa
fazer
mais no seu jogo do que alguém com
um computador lento. Por exemplo, você não
gostaria que eles caíssem mais rápido. Vamos usar uma forma
geral de atualização. Ainda se
chama praticamente todo quadro, você pode pensar nisso
como a mesma coisa, mas é uma boa
convenção fazer isso. Agora vamos começar a
codificar o movimento real do nosso jogo dentro dessa
atualização fixa, acompanhe como eu faço A primeira coisa que vou
fazer é criar uma nova variável e chamá-la de x. E
, na verdade, posso fazer
isso digitando float x.
A diferença
entre a variável aqui em cima
e a variável aqui em
cima é que essa variável é acessada
por tudo no script Todos esses lugares
onde chamamos código podem falar sobre
essas variáveis. Mas dentro de uma delas, se eu criar uma variável que só
pode ser acessada
dentro dela. Se eu entrar na atualização e
tentar falar sobre x, ele não saberá do
que estou falando, mas dentro da atualização fixa, saberá. E isso é bom para nossos propósitos porque, na verdade,
só precisamos que esse float x esteja dentro da atualização
fixa
para ser igual à entrada,
obter o eixo bruto, abrir parênteses, aspas
duplas e digitar O que isso basicamente vai
fazer é ser outro
recurso do Unity. Basicamente, isso nos
permitirá simplificar um pouco
nosso movimento,
porque em vez de dizer,
ok, se o jogador estiver
segurando essa tecla, faça isso. Se eles estão segurando
essa chave, faça isso. O que estamos dizendo aqui
é uma variável criativa chamada x. É do tipo float E essa variável será usada para armazenar se o jogador está
pressionando determinadas teclas. O que essa linha
aqui, input get axis horizontal faz,
é dizer para a unidade. Se, no minuto em que executar esse código, o jogador estiver
pressionando a
tecla de seta para a direita ou a tecla D para SD e, em
seguida, coloque o valor de um em x. Se estiver pressionando a
tecla A ou a seta esquerda, coloque um valor de menos um. E se eles não estiverem
pressionando nenhuma dessas teclas, coloque um valor zero. Então, você pode ver, basicamente,
o que isso vai fazer é
que cada quadro dirá,
ok, eles estão se
mantendo pressionados? Se sim, faça este. Eles estão
se segurando? Se sim, faça isso menos um.
Eles não estão tocando em nada Está bem? Faça com que isso seja
zero. E você pode imaginar como isso será
útil para o nosso jogo, porque basicamente
permitirá que cada quadro verifique se o jogador quer que nos
movamos ou se
devemos continuar nos movendo ou se
devemos retroceder, etc., etc., etc Essa é a primeira linha
de código do nosso script. E abaixo disso,
vamos escrever outra linha de código
que
dirá R B como referência à velocidade corporal da nossa
crista Então, vamos editar
basicamente o quão rápido estamos nos
movendo é igual ao vetor dois. Agora, isso não
é muito importante, é basicamente um vetor, dois é um vetor de dois componentes Estou dizendo, ok, eu
quero minha velocidade, obviamente velocidade,
eu vou ter uma velocidade x e uma velocidade y. E eu quero que isso seja, vou atribuir coisas
a isso usando o vetor. Se eu atribuí 1.1, diz, ok, faça o x um
e faça o y. Se eu definir 2.1, ele diz fazer
o x dois e o y um. Isso é basicamente, como eu disse, não
é muito importante. Pense nisso como
um espaço de armazenamento. Se você sabe o que é
um vetor, tenho certeza
de que faz muito sentido. Mas se você não
encontrou um vetor ou não estudou
muita física, pense nisso como
um espaço de armazenamento para dois
números ou dois valores. Agora eu estou
dizendo, ok, eu quero que minha velocidade RB seja
esse novo vetor dois, e eu vou ter que colocar um x e um y porque eu obviamente
tenho uma velocidade x horizontal
e uma velocidade y Vou fazer com que
minha velocidade x seja igual a x e vou
separá-las por uma vírgula e
vou fazer com que minha velocidade y RB seja a velocidade Y. Isso é basicamente
como dizer, ok,
pegue a velocidade do meu corpo rígido e faça a velocidade x x e faça com que
a velocidade y seja a velocidade y, a velocidade
y a x e vou
separá-las por uma vírgula e
vou fazer com que minha velocidade y RB seja a
velocidade Y.
Isso é basicamente
como dizer, ok,
pegue a velocidade do
meu corpo rígido e faça a velocidade x x e faça com que
a velocidade y seja a velocidade y, a velocidade
y não muda. Se eu fizesse esse RB
fazer a velocidade ponto x, essa linha não faria
absolutamente nada Porque é básico dizer,
ok, pegue a velocidade
do corpo rígido e faça com que seja a velocidade do corpo rígido,
o que obviamente não tem nenhum
efeito E é isso que eu
quero para o eixo y, porque eu não quero que o
jogador fique no ar caindo. E então eu clico na seta para a
direita e, de
repente, começo a me mover
em linha reta. E isso é o que aconteceria
se eu definisse isso como zero, por exemplo, ou
algum outro número. Não quero que isso mude, mas quero que isso mude
porque quero poder influenciar para onde o jogador
está se movendo
para a esquerda e para a direita. Na verdade, essas são basicamente as duas linhas de código de que precisamos para criar o movimento mais rudimentar possível Se eu voltar para o Unity e for até meu
objeto de jogo aqui. Quando termino de
recarregar meu script, vou até meu
objeto de jogo e o arrasto aqui Vamos movê-lo
para baixo. E vamos arrastá-lo até lá. Podemos ver que tenho meu roteiro
incrivelmente simples e vou
arrastar esse corpo rígido até aqui que meu roteiro saiba onde está
o corpo rígido Então eu estou falando sobre,
porque eu estou falando sobre isso, mas
na verdade eu não o vinculei. É assim que vamos
vinculá-lo no Unity. É uma das maneiras mais fáceis
e, na verdade, não
preciso alterar essas variáveis
porque não as
usei em meu script. Mas você vai ver se eu vou
em frente e clico em play. Agora eu caio normalmente. Mas se eu clicar em
todas as teclas, também em
todas as teclas de seta, posso me mover da mesma forma que faria em
qualquer outra plataforma. Novamente, obviamente, esse não é um
roteiro de movimento muito bom porque eu não consigo pular, não
consigo fazer nada. Na verdade, eu
nem consigo atravessar essa coisa sem
cair no abismo Se eu tentar,
vou cair. Portanto, não é um roteiro de movimento muito
bom porque não estou me movendo
rápido o suficiente, não consigo pular. Mas essa é a base
do meu roteiro de movimento. Eu disse, ok,
dependendo se estou
segurando certas teclas, defina esse valor e atribua esse valor à
velocidade do meu corpo rígido. Portanto, certifique-se de que estou me movendo
na direção em que esse
valor deve me fazer mover. Mas, obviamente, queremos torná-lo um pouco
mais interessante. Então, vamos começar multiplicando
isso pela velocidade do jogador. E é aqui que vamos
começar a usar nossas variáveis. Agora, isso nos
permitirá determinar a
rapidez com que o jogador se move com base na variável de
velocidade desse jogador. E, na verdade, vou
excluir essa placa inicial porque não
vou precisar dela agora. Eu poderia adicioná-lo
mais tarde,
dependendo de como eu edito o script. Mas, por enquanto, está tudo bem ter as coisas como estão agora. Agora, na verdade, há algumas
mudanças que eu quero fazer. Isso é apenas
para ilustrar como vamos criar
nosso roteiro movido Eu estava tentando
explicar como diferentes variáveis funcionam e como funcionam, mas queremos tornar
isso um pouco melhor. Então, a primeira coisa que
vamos
fazer é ir até o topo e criar
um novo carro alegórico público Chame isso de x, então,
na verdade,
não vamos nos referir a uma variável
apenas dentro desse método. Queremos que seja uma
variável que possa ser acessada em qualquer lugar
dentro do script. E então vamos
prosseguir e realmente mover esse código de atualização fixo
para o bloco de atualização. E o que isso vai
fazer é basicamente, em vez de basear esse valor
em um determinado intervalo, vamos querer atualizar
isso a cada quadro O que é uma maneira muito
melhor de codificar. Você pode pensar que,
como regra geral, você deve seguir qualquer
código baseado em entradas ou no que os jogadores estão fazendo deve ser atualizado. Qualquer código baseado
em física ou em mover coisas com base nisso
deve ser atualizado de forma fixa. Porque isso basicamente nos permitirá
dizer, ok,
se você tem um
computador mais rápido, com certeza, você deve ser capaz de
reagir mais rápido. Mas então você poderá se mover na mesma velocidade de alguém com um computador mais lento,
porque isso é justo, exagerando demais o
quanto isso tem um efeito Porque eu prometo que você poderia codificar tudo e
atualizar uma atualização fixa. Você provavelmente não
conseguiria notar uma grande diferença, mas é uma convenção de codificação muito
boa para fazer o que estou fazendo aqui Dito isso, temos mais
algumas coisas a acrescentar ao nosso roteiro apenas para torná-lo um roteiro de movimento um pouco melhor. Nós já multiplicamos pela velocidade
do jogador, obviamente. Mas a última coisa que
vamos adicionar é um salto, que possamos realmente começar a nos mover. E vou criar
um novo vazio público, que é como se eu quisesse um novo
bloco de código que eu possa chamar Em um determinado momento,
vou chamá-lo pular dentro desse vazio público Vou copiar
esse código aqui. Copie e coloque de volta lá. E vou dizer que
agora, quando eu pular, quero minha velocidade de RV, então a velocidade do meu jogador seja outro novo Velocidade Rb x. Desta vez, não estamos alterando
a velocidade x Queremos que a velocidade x
permaneça a mesma quando pulamos. Porque, obviamente, não
queremos
pular para frente ou para trás, só
queremos pular para cima, seja qual for a velocidade x,
configurá-la como era E também, obviamente,
não queremos que seja zero. Porque então, se você estiver se
movendo, tente pular, você simplesmente pulará
no lugar certo,
permanecerá na velocidade em que
estiver se movendo. Mas queremos pular para cima, então vamos definir a velocidade
y para esse valor Altura do salto, que
obviamente também podemos mudar. Agora, o que isso vai fazer é toda vez que
chamarmos esse vazio, mudaremos nossa velocidade e
diremos,
ok, avance como
você estava com x, mas pule até onde
esse valor permitir Com a velocidade y, o que
estamos realmente dizendo é mudar sua velocidade
para algum valor E isso
fará com que você atire para cima
e, obviamente,
quando a gravidade chegar, você cairá de
volta ao chão. Mas é isso que o script faz. Agora, isso realmente nos
leva quase
ao final do nosso roteiro.
É incrivelmente simples. Há três linhas
de código até agora
e, na verdade,
temos tudo o que
precisamos para poder nos mover
e pular no Unity. Se eu voltar aqui, vou realmente
mudar
esses valores agora. Vamos fazer com que a altura do salto seja
algo como dez. Vamos fazer com que o jogo tenha uma velocidade de cinco. Você pode ver, na verdade, se eu
seguir em frente e agir assim, eu deveria ser
capaz de me mover e pular. Mas falta uma coisa. Na verdade, nunca estamos
chamando esse bloco de código. Então não há como eu
dizer a mim mesma, ok, eu quero chamar esse
código para isso, vamos precisar usar
outro comando de entrada. Vamos descer até aqui. Digamos que,
contanto que essa condição seja verdadeira, faça o código abaixo dela,
insira a tecla dot get down,
abra parênteses, abra parênteses, espaço no
código de tecla ou o que
você quiser Na verdade, vou
usar o keycode porque prefiro pular
SD em vez de espaço, mas você pode usar o que
quiser. Sinta o jogo. Em seguida, vamos colocar
um colchete aqui e Visual Studio ou
qualquer outra coisa que você vá usar vai preenchê-lo
automaticamente Você basicamente quer um suporte C lá e um suporte co E isso nos
dirá qual código está dentro dessa instrução if,
desde que isso seja verdade, desde que você esteja
pressionando a tecla ou apenas pressionando
o WK. Em seguida, execute esse código. E tudo o que eu vou
querer fazer é chamar esse salto de vazio Então, espero que tudo isso faça
muito sentido. Estou me movendo muito rapidamente e há muitos
conceitos aqui, especialmente se você
nunca programou antes, que pode parecer um
pouco intimidante Mas, basicamente, tudo o que
temos
agora é
esse espaço de armazenamento, temos nossas
variáveis que
armazenam coisas como configurações. Então, estamos definindo esse valor com base no que o
jogador está movendo. E estamos dizendo que se
eles estiverem pressionando a tecla Wy, então chame esse código aqui E esse código está dizendo,
ok, mova-se nessa direção. E esse código aqui, cada quadro diz que
se move
nessa direção de acordo com o que o jogador está
fazendo com o teclado. Então, como eu disse, pode não parecer muito intuitivo
no momento, mas espero que faça um pouco de sentido
o que estamos tentando fazer E se eu voltar ao meu jogo, poderei pular o RestWK Mas há mais uma
mudança que eu quero fazer E eu só quero
ser capaz de pular enquanto estiver no chão Então, vamos voltar aqui
e adicionar um e comercial duplo
e dizer que está aterrado E isso vai
dizer que somente enquanto estivermos aterrados, poderemos
realmente executar esse código Porque eu não quero ser
capaz de pular no
meio de lá. Eu só quero ser
capaz de pular do chão. E vamos adicionar mais
uma condição que nos permitirá
determinar se estamos aterrados aqui Vamos dizer vazio
na colisão, digite dois D caso de colisão, isso significa basicamente
que, quando colidirmos os aceleradores que adicionamos
anteriormente na caixa, os colisores chamarão esse vazio aqui Contanto que você
colida, eles estão bem. Nós colidimos e chamamos isso de vazio. Essa colisão está armazenando
o que colidimos. Vamos dizer que
se colisão, o game object dot compare tag vai abrir príncipes e
vamos digitar ground Então, vamos dizer que fundamentado
é igual a verdadeiro. Vamos fazer um
código
muito semelhante para sair de uma colisão Copie esse código exatamente, exceto se
configurado como aterrado para forçar. Agora, isso pode parecer muito, pode
parecer um pouco confuso especialmente em comparação com
o resto do roteiro, mas na verdade é muito fácil Esse vazio aqui,
assim como update e start são chamados pelo Unity,
é chamado pelo Unity Toda vez que colidimos
com algo, o mecanismo de física
cuida disso, então estamos colidindo com
essa coisa e a
armazenamos nessa colisão variável E por baixo disso, o que
estamos dizendo é, ok,
se colisão é a
coisa com a qual colidimos, ou melhor, o colisor com o qual
colidimos Se o objeto ao qual está
anexado tiver uma tag ground, quero
ter certeza de que configurei essa variável aqui
como verdadeira, e isso me
permitirá pular Caso contrário, se
sairmos de uma colisão, se sairmos de um colisor, se o colisor do qual saímos for chamado
de solo, quero fazer a mesma coisa,
exceto configurá-lo para A última coisa que precisamos
fazer antes de realmente testar isso é
voltar ao nosso jogo, entrar no nosso armazenamento, selecionar
nossos itens de três andares e queremos adicionar
essa etiqueta aterrada Clique em adicionar tag, aqui, clique no sinal de adição e
digite no chão. Não, vou voltar
para meus andares e vou me certificar de que estão todos
prontos para o chão. Essas tags são basicamente uma
forma de você conseguir
identificar determinados objetos
ou grupos de objetos. Todos esses objetos fazem parte
do chão e eu quero que
todos sejam uma etiqueta no chão. E isso me permite
escrever esse código aqui que me diz quando
eu caí no chão ou não. Na verdade, isso é
tudo o que
precisaremos para fazer com que nossos jogos se movam. Se voltarmos ao
player, veremos
aqui que obviamente
os editamos pela última vez no modo de jogo. Então, vamos alterá-los no modo
normal, isso economiza, eu tenho que fazer seis, vou fazer o salto com a altura cinco. Obviamente, não vou
querer alterar nenhum
deles porque eles estão
incluídos no meu código. Clicamos em Player e
clicamos, vamos ver o que acontece. Em primeiro lugar,
caímos, assim como fizemos, e
pousamos no chão. Se eu rolar para baixo, posso
ver que o meu está fundamentado, é verdade, que é
exatamente o que eu quero E se eu clicar no WK, ele vai de falso para
verdadeiro. E eu posso pular. Se eu clicar no WK
midair, ele não funcionará. Então, meu salto está
realmente funcionando muito bem. E se eu me mover para a esquerda e para a direita,
podemos ver que é um pouco rápido. Eu quero fazer esse movimento
quatro, voltar ao meu jogo. E isso deve
ser, na verdade, tudo o que precisamos para um movimento básico, a queda
dos scripts E eu pulo e
, obviamente, posso me mover
exatamente como eu preciso. Agora, isso pode parecer
um pouco idiota
e, obviamente, vamos ajustá-lo
à medida que avançamos Mas isso é meio
básico para o nosso jogo. O que eu realmente vou querer, com base na plataforma que eu quero, é torná-la uma velocidade um
pouco mais rápida, um salto um pouco mais alto. E, na verdade,
vou querer mudar essa
escala de gravidade para dois. E talvez eu precise
alterá-los um pouco mais. Talvez eu precise fazer
esse oito aqui. Podemos ver o que isso parece. Parece um pouco melhor. Eu sei que parece um pouco
irregular com esse movimento, mas é um estilo bem retrô e fácil
de mover, mas caso você realmente
não queira isso, e eu não tenho certeza se
vou continuar com isso Acabei de adicioná-lo originalmente
porque era bem simples. Na verdade, há
uma solução muito simples para tornar isso
diferente agora. Você pode ver que é uma coisa
muito irregular. Se você não quiser isso,
prossiga com nosso código e removeremos essa palavra bruta. Isso basicamente
dirá à Unity:
Ok, não arredonde para 10. Faça com que seja mais gradual, dependendo quanto tempo eles estão
segurando a chave. Se movermos isso, podemos
ver isso em ação aqui de forma um pouco mais suave
com base em como você deseja se mover. Na verdade, esqueci de
trocá-los de volta, então vamos fazer disso um
6,8
e mudar a escala de
claridade dois Se pudermos jogar novamente, podemos ver que agora temos um movimento um pouco mais suave e isso faz com que pareça muito melhor Agora, a razão pela qual eu
usei essa regra primeiro foi porque achei que era uma maneira mais fácil de
ilustrar o conceito Mas geralmente é
melhor usar esse eixo que suaviza a coisa porque parece
um pouco mais natural Eu poderia mudar isso de
volta. Obviamente, podemos ajustá-lo à medida que avançamos
no jogo Espero que você esteja
acompanhando e tenha
conseguido criar esse
roteiro de movimento muito simples e que possamos seguir em frente Agora esse é o
fim do vídeo. Mas há uma última
coisa que eu quero acrescentar, já que adicionamos movimento, e é uma mudança incrivelmente
simples, tudo o que queremos fazer é
ir até aqui e criar um novo material
físico. Vamos descobrir
aqui dois materiais físicos, dois D, vamos
chamá-lo de jogador. E vamos definir
o atrito para zero. Isso basicamente
nos permitirá não
ficar presos às paredes. Não sei se você
viu pela última vez, vamos adicioná-lo
ao nosso colisor de caixas Agora, se pularmos contra a parede,
não vamos nos ater a ela. Porque o que acontecia
antes era que, se caíssemos contra a parede
e nos
mantivéssemos firmes nela, na verdade ficávamos presos
lá, mas agora voltamos direto para a parede. Na verdade, esse
é o fim. Eu sei que este é
um vídeo bem longo e havia
muita coisa acontecendo, mas foi o
primeiro roteiro. Então, obviamente, são
muitos conceitos novos ao mesmo tempo. Então, espero que você tenha
acompanhado e tenha conseguido criar esse roteiro de movimento
assim como eu fiz É incrivelmente
simples, como eu disse. E eu mudei o
acesso a isso agora, mas posso
ajustá-lo à medida que avança meu jogo, porque não tenho
certeza do quanto gosto dele, mas vou ver que basicamente esse é o jogo por enquanto e é tudo o que
precisamos ter Então, se você está
acompanhando, você tem seu movimento
exatamente como é meu. Ótimo. E eu vou ver
no próximo vídeo onde vamos começar
a adicionar mais e mais conceitos para tornar nosso jogo uma plataforma mais
impressionante. Mas se você tem exatamente o que eu tenho por enquanto, isso é ótimo.
5. 4. Introdução de prefabs: Olá, e bem-vindo de
volta à Unity. Agora, no último episódio, fizemos algumas coisas. Adicionamos nosso player,
adicionamos nosso script de movimento. Bem, criamos nosso player
para que possamos realmente pular e adicionamos
nossa primeira linha de código, todo o nosso script. E também fizemos
esse material para jogadores
logo no final. Espero que você tenha conseguido
acompanhar tudo e chegar ao estágio em que
estou no meu jogo. Agora, se não, e o
seu está um pouco diferente, eu recomendo
que você volte e assista
novamente talvez uma ou duas vezes, só para que você possa
acompanhar e ter certeza de que tem tudo
como eu tenho agora Obviamente, como eu
disse, meu roteiro será anexado
a cada vídeo. E praticamente todos os
arquivos que eu crio junto com este curso serão anexados aos
respectivos vídeos. Então você pode ir em frente
e baixá-lo. Se o seu não estiver funcionando,
talvez veja onde seu código é diferente do meu ou o que você está
fazendo de forma diferente. E, obviamente, usar
meus arquivos deve fazer com que funcionem completamente bem. Então, vá em frente e não se deixe intimidar pelo ritmo
das coisas E você pode assistir novamente as coisas
e usar os arquivos, e deve ser capaz de
acompanhar e fazer que tudo
funcione em um piscar de olhos Portanto, não desanime. O desenvolvimento de jogos é difícil, mas se você tem tudo até o ponto que eu
tenho agora, ótimo trabalho. Porque,
na verdade, fizemos o último episódio por muito tempo. Se você escreve até
onde eu estou, isso é ótimo. Agora, antes de começarmos
com esse episódio, que será
sobre prefabs, vamos
começar
reordenando um pouco essa
pasta de ativos Então, vamos em frente
e clique com o botão direito do mouse. Vamos criar uma nova pasta. E vou chamar
isso de diverso porque sempre
há arquivos aleatórios no projeto
para
os quais você realmente
não precisa ter uma pasta
dedicada, como esse para
os quais você realmente
não precisa ter uma pasta
dedicada material
de Não vamos fazer
muito disso. Vou colocar
isso na minha pasta Misk. E qualquer outra coisa que eu
encontrar no meu jogo, vou colocar na
pasta Misk se ela não couber em nenhuma
das outras pastas Dito isso, também precisaremos
criar uma nova pasta aqui
embaixo,
e vamos
chamá-la de prefabs Vamos descobrir exatamente
o que é
um pré-fabricado e como podemos
fabricá-lo em um minuto Mas, por enquanto, basta criar a
pasta porque você vai
querer ter um
espaço de armazenamento para seus prefabs Agora, o que exatamente é um pré-fabricado? Mencionamos
que essas coisas temos aqui em cima são objetos. Agora, eles são os
blocos de construção do nosso jogo
aos quais vamos atribuir lógica
na forma de componentes. E isso nos permitirá
construir nosso jogo do zero. Mas só podemos criar esses objetos enquanto estamos desenvolvendo em Unity
no momento. Por exemplo, se eu quisesse
criar um novo inimigo, teria que ir até
aqui e criar um novo objeto como esse
para o sprite de objetos, talvez pegar um triângulo, mudar a cor e adicionar lógica a partir daí Mas no
desenvolvimento de jogos, geralmente, você quer ser capaz de
criar objetos em tempo de execução. que significa que enquanto
o jogo está rodando, enquanto o jogador está
realmente jogando, você quer ser capaz de
criar e destruir objetos. E para fazer isso,
vamos usar prefabs. Agora, se isso é um pouco
confuso no início por que precisamos fazer isso,
deixe-me dar um exemplo Digamos que temos um jogador e ele precisa ser capaz de
atirar em coisas. Quando você atira em algo, você realmente quer criar
um objeto de bala Você quer criar
um novo objeto que atire com sua arma, viaje pela tela e faça certas coisas ao
atingir um inimigo. Agora, a única maneira, ou a maneira mais fácil, de fazer isso é realmente usando prefabs Porque, basicamente, isso permitirá
que você crie um objeto em tempo de execução,
sua bala, faça com que ele exista por toda a duração
e depois o destrua Quando você não precisar mais
dele, digamos que, ao atingir um inimigo ou uma parede, você pode destruir esse objeto. Portanto, ele existe apenas por um
período limitado de tempo de jogo. E vou explicar
exatamente como eles funcionam,
como você pode criar
esses prefabs e como eles podem ser
usados para trazer objetos para seus jogos
em um minuto Mas, no momento, tudo o
que você precisa saber é que os pré-fabricados são usados
para criar objetos Então, como exatamente usamos
prefabs para criar objetos? Bem, começamos como
faríamos com qualquer outra coisa. Vamos até a
hierarquia e clicamos com o
botão direito do mouse em Criar no objeto E eu vou fazer,
o primeiro pré-fabricado que vou fazer é um Então, o inimigo tem algo em
que pode cair e morrer no triângulo do objeto
sprite Só para criar o
primeiro tipo de inimigo do jogo, vou chamar isso de pico Vá em frente e
diminua um pouco o tamanho. Digamos 0,8 no x e no y, e eu vou
mudar sua cor para vermelho
para que saibamos que é um inimigo. Então, agora temos nosso primeiro inimigo. Obviamente, isso
não está nem perto de terminar. Há algumas outras
coisas que precisamos acrescentar. Primeiro, a primeira coisa
que vou fazer é mudar essa tag, assim
como fiz com o chão. Vou clicar em Adicionar tag. E vou fazer
dela uma etiqueta inimiga. E não vamos
usar isso imediatamente, mas isso será útil mais tarde. Portanto, certifique-se de não
deixar essa etapa por enquanto. A próxima coisa que vou
fazer é adicionar um tipo de alida Se eu pesquisar Alida, você pode ver que eu tenho um
monte de Kaliders Mas o que melhor se encaixa nisso é
um polígono Alider, que obviamente é
como quatro Você pode ver que, se rolar para baixo, há
praticamente aceleradores para cada tipo de objeto que você
possa ter Obviamente, evite aqueles
que não são dois D, como um
colisor de esferas, um colisor de caixas ou um colisor de cápsulas, porque os dois D são
o que vamos usar Mas esse colisor de polígonos
tem apenas uma versão em dois D,
então não se preocupe, não há três triângulos D ou
colisor de pirâmides, então você realmente não pode errar Mas o que fizemos agora foi
adicionar nosso colisor de polígonos E, na verdade, antes que eu
esqueça, eu também quero fazer disso um gatilho agora. Isso não é muito importante no momento porque
, na verdade, vamos apenas adicionar nossa
lógica inimiga e o fato que você pode morrer ao
atingi-los mais tarde. Mas esses são apenas
alguns passos que você deseja seguir
agora para poder
configurar seu inimigo corretamente. Então, queremos
nomeá-lo, estamos nomeando. Não é tão importante,
mas é apenas útil. Queremos ter certeza de que
definimos a etiqueta. Queremos adicionar um
colisor e torná-lo um colisor de
gatilho Então você pode ver agora,
se clicarmos em play, obviamente nada vai acontecer quando entrarmos nisso. Mas você deve ser capaz de ver que
somos realmente
capazes de passar, o
que é mais ou menos
o que queremos, porque não queremos que esse objeto seja algo que
possa existir no espaço, mais como
um sinal de que, quando eu o atinjo, posso sofrer
danos ou algo assim. Obviamente, você não quer realmente não ser
capaz de superar isso. Porque se você está
correndo e bate em um objeto, você quer ser capaz de
passar por ele e sofrer danos, mas não parar e meio que não
conseguir passar. Então, essa é toda a
configuração que precisamos fazer para nosso objeto
no momento. Mas
certifique-se de
seguir em frente e adicionar colisor de
polígonos e
transformá-lo na etiqueta inimiga Agora, isso é realmente o que
vamos usar para
fazer nosso primeiro pré-fabricado. Então,
vamos clicar duas vezes nisso. Eu vou levá-lo até
aqui. Clique no objeto. Vou arrastá-lo para baixo até minha
pasta Assets. E o que isso
vai fazer é criar esse novo arquivo chamado spike prefab E você pode ver aqui, na
verdade, muda para azul. Agora, o que é esse prefab, você pode pensar nele
como um modelo de objeto Então, o que eu estou basicamente fazendo
aqui é dizer, ok, eu tenho esse objeto que
eu quero fazer como um modelo ou uma
espécie de carimbo E então eu posso fazer cópias
desse objeto e
trazê-las para o meu jogo. Esse é o tipo de modelo
para o objeto que estou criando. Então, eu posso inserir algum
código e dizer, ok, aparecer em um pico E ele sabe que aparecer nesse objeto específico com
esse sprite específico e esse polígono específico e
praticamente todas as outras qualidades que acabei de adicionar agora, ele sabe que é a isso que estou me referindo quando quero desovar em uma
espiga Então, vou prosseguir e excluir aquele extra por enquanto. E, na verdade, eu também
vou excluir isso
da minha cena agora. Não se preocupe, porque
isso
na verdade não elimina o pico Podemos ver que ainda está
aqui em prefabs, e se eu clicar duas vezes nele,
posso editar o prefab real Então, aqui estou editando o
modelo real para o prefab. Se eu arrastar um prefab para dentro, ele está instanciando esse objeto
ou criando esse objeto É assim que se chama criar uma instância desse
prefab. Se eu mudar as coisas nesse
pré-fabricado aqui no jogo, certifique-se de observar
que ele na
verdade não substitui Está mudando essa
instância específica de um prefab. Então, eu meio que
já o criei. Eu posso fazer o que eu
quiser com este. Mas isso não vai
mudar o fato que, quando eu gerar outro, será exatamente o mesmo Se eu quiser alterar
o selo real ou o modelo real,
tenho que fazer isso aqui Porque se eu fizer isso,
por exemplo, laranja, você pode ver agora que
toda vez que eu desovo nesses pré-fabricados,
eles são Observe também que esse prefab, que não alteramos, está
vinculado ao arquivo original No minuto em que fazemos
uma alteração, o link muda porque
eu mudei essa cor. Se eu mudar
isso de volta para vermelho, podemos ver que o verde e o amarelo permanecerão
verdes e amarelos. Mas os que eu não
mudei são vermelhos. Mas outras quantidades que eu não mudei
serão efetivas. Por exemplo, se
eu fizer a escala 0,85 que não seja 85,
torne-a um pouco maior Podemos ver que todos esses pré-fabricados realmente
ficaram bem maiores, mas este não, porque esse
já havíamos mudado Era 214-41-2616 E
se eu voltar aqui e mudar isso de volta para oito,
podemos ver que permanece em
214-41-2616 Porque
basicamente, no minuto em que você altera uma certa
qualidade neste pré-fabricado,
ele 214-41-2616 Porque
basicamente, no minuto em que você altera uma certa
qualidade neste pré-fabricado, minuto em que você altera uma certa
qualidade é seu próprio pré-fabricado. Portanto,
você não será substituído por esse pré-fabricado original que é
indicado por esta pequena linha azul Essas são as coisas que
eu mudei no pré-fabricado. Isso é apenas algo que
você precisa observar, não
é muito importante. Mas observe que se você quiser
alterar seu pré-fabricado real, você precisa fazer isso aqui Então, vou
prosseguir e realmente excluir todos esses
picos por enquanto E vou começar antes
de
começar a fazer mais
alguns pré-fabricados Deixe-me fazer mais uma simples, criar dois objetos e
eu vou fazer um círculo. E esse será outro inimigo mais tarde, será uma bola de
espinhos Você verá quando adicionarmos picos sprites
e tudo mais, mas vamos mudar
isso para vermelho também Vamos adicionar um colisor circular. E vamos garantir que
ele tenha a etiqueta inimiga. Certifique-se de que seja um gatilho, é tudo o
que precisamos. Também podemos fazer com que isso seja
um pouco menor. Na verdade, isso é
tudo o que
precisamos para criar nossos novos pré-fabricados Então, vamos arrastá-lo para baixo novamente. Podemos ver agora que
temos nossos dois pré-fabricados. Vou deletar
isso. Na verdade, vou renomear
isso para spike ball. Agora, se
clicarmos duas vezes, podemos ver que
temos nosso espigão
e nossa bola de espinhos, ambos
são inimigos
e ambos são vermelhos E ambos têm aceleradores acoplados, que são gatilhos Então, eles não serão muito afetados
pelo espaço, mas avisarão
ao motor de jogo que, ok, eu bati em alguma coisa. É importante
observar que outros colisores também
fazem isso Só que eles também têm a funcionalidade
adicional de também existirem como objetos no espaço-tempo o que pode influenciar a física. Vamos voltar a esses pré-fabricados
e garantir que estejam todos
configurados exatamente como
queremos que sejam Porque agora o que
vamos fazer é criar um novo prefab, que
será nosso bloco de mapa A razão pela qual estamos criando esses prefabs é
porque vamos
realmente começar a criar
nosso script de geração de mapas No momento, temos
um jogador e
temos três blocos dos quais
ele pode pular. Mas é mais ou menos isso.
Não temos um jogo infinito. Não temos nada para
onde possamos nos mudar. Nós só temos três coisas, e isso é meio que
o jogo inteiro. Então, embora eu
os tenha preenchido com todos os tipos de obstáculos
interessantes,
há apenas três deles. E, obviamente, queremos que
o jogo continue e tenha o maior número
possível. Então, para fazer isso,
teremos que criar um objeto pré-fabricado com esse objeto de piso e colocar
o que quisermos nele E então vamos
querer escrever código que vai
gerar isso Agora, vou
começar a fazer exatamente isso,
mas antes disso, deixe-me
dizer uma isenção de responsabilidade A maneira como vamos fazer
isso é
criar um monte de ladrilhos
diferentes. Pense nelas como
plataformas no jogo, e você pode criar quantas quiser. Chegaremos a isso quando o
codificarmos mais tarde. Mas, basicamente, essa será
a lista completa de possíveis
peças nas
quais o jogo pode aparecer Se você criar apenas um
com um único pico, seu jogo será um monte de coisas com um
monte de pontas.
É isso mesmo. Mas se fizermos um com um
espigão, um com dois espigões,
talvez um com três espigões, um com um espigão e uma bola de espigão,
um com duas bolas de espigão um Quanto mais você adicionar, mais variado seu
jogo ficará. E você verá que, à medida que
adicionamos mais inimigos e coisas mais interessantes, podemos criar plataformas mais
variadas e criar um jogo mais
interessante. Mas estou me precipitando. Vou
começar criando um básico e
mostrando como posso criá-lo para criar
um piso
pré-fabricado Vou fazer exatamente a
mesma coisa que fiz antes. Vou fazer
isso um pouco maior, mas acho que é um
bom tamanho para uma plataforma. Vou arrastá-lo para baixo e agora podemos ver que tenho um
novo pré-fabricado chamado andar dois Vou chamar isso
de piso 1. E esse será
meu piso básico. Se eu clicar duas vezes sobre isso agora você verá que posso
acessá-lo dentro do meu editor pré-fabricado e na verdade,
posso personalizar exatamente
esse desejo. Agora, como eu disse, o que
é isso é
que serão as peças que vamos
gerar em nosso jogo agora É apenas um ladrilho básico, não
há inimigos, não
há obstáculos,
é apenas um ladrilho. Então, vamos torná-lo
um pouco mais interessante. Vou começar
adicionando um pico. Deixe-me arrastar do meu prefixo
até esse prefabitor. Agora que adicionamos, podemos ver que
isso é chamado
de objeto filho. Ele está vinculado ao objeto
original e, se eu mover o
objeto original, ele se move com ele. Vimos isso mais cedo,
quando armazenamos todas as nossas falhas dentro
do objeto principal de armazenamento Você pode pensar nisso
como o objeto maior ou como o
objeto da pasta aqui. É chamado de objeto pai. E estamos adicionando um pico
dentro do nosso objeto principal. Vou colocar um
espigão lá embaixo. Está muito bem centrado. Não
importa muito deixar isso muito bonito, porque
obviamente adicionaremos sprites e tudo
mais mais tarde Mas isso é um espaço reservado,
mas eu vou copiar isso, e vou colocar
outro lá Mova-o um pouco para baixo. Esse é praticamente o
nosso primeiro objeto finalizado e criado. Obviamente, não criamos nenhum efeito de morte ou
nenhum sistema de saúde. Não vai fazer muita coisa agora. Mas se voltarmos ao nosso jogo
e virmos nosso piso, podemos ver que ele realmente
está vinculado ao nosso objeto e criou exatamente o que
queríamos quando estávamos
jogando. Vamos escrever um roteiro
que vai dizer, ok, coloque um lá, coloque um
lá e coloque um lá. Podemos ver que temos uma plataforma,
um jogo que está começando a se formar. Se
chutarmos, podemos nos mover e fingir que estamos
jogando o jogo Podemos pular aquela plataforma
e pular essa. Obviamente,
teríamos morrido lá. Mas você entendeu a essência. Nosso jogo não será
tão difícil, não se preocupe. Mas será assim que
usaremos
esses objetos para jogar nosso jogo e criar
nosso mapa interessante. Então, o que vou
fazer com o resto
deste vídeo é criar mais
alguns prefabs Você não precisa seguir
exatamente o que estou fazendo, você pode fazê-los da
maneira que quiser. Eu recomendaria seguir
meu espigão e minha bola de espinhos como nossos inimigos, porque
adicionaremos alguns
sprites E se você quiser
usar meus sprites, eu já criei esses
sprites Então, se você inventar
algum outro inimigo, terá que criar seu próprio sprite ou criar
um plano alternativo Mas se você quiser fazer o jogo exatamente
como eu estou fazendo, talvez fique com esses
dois por enquanto. Obviamente, depois de
avançar no curso, talvez
você possa começar a adicionar seus próprios inimigos e criar
suas próprias peças. Mas, especialmente se for a
primeira vez que você usa o Unity, acompanhe esses dois
objetos o máximo possível. Mas, dito isso, você pode fazer as peças que quiser, então você não precisa fazer
duas, você pode fazer três. Obviamente, torne todos
eles possíveis, porque você quer que algo em
seu jogo seja impossível. Mas você pode ser
criativo e criar peças
diferentes o
quanto quiser. Você também pode fazer
quantas peças quiser. Quanto mais, na verdade, como eu
disse, você tiver, melhor. Porque isso significa que
o jogo será mais variado. Obviamente, você
quer ter mais blocos, os quais você pode
ter que começar
copiando e colando. E vou chamar
esse piso de dois. Na verdade, vou
fazer isso
várias vezes porque vou começar fazendo
oito peças aqui. Eu tenho oito, na verdade
, dez agora. Eles têm nomes estranhos e obviamente são
todos iguais Mas eu vou editá-los agora. Então eu tenho piso
um, piso dois. Vou fazer esse piso três. Isso, é claro, piso quatro. E assim por diante, até o
piso dez. Veja, agora eu tenho meus
dez pisos. Agora, enquanto estou fazendo
isso,
vou deixar meu jogo
ainda mais ordenado. Vou clicar com o botão direito do mouse e criar uma nova pasta. Vou chamar
isso de um piso de azulejos. Na verdade, vou colocar
tudo isso aqui, arrastá-lo e clicar duas vezes em cada um. E então, quando eu
quiser editá-los,
obviamente, se eu
quiser adicionar inimigos, tenho que sair imediatamente, voltar aos prefabricados e adicioná-los assim Mas isso significa que todos
os meus ladrilhos estão armazenados aqui para que eu possa
acompanhá-los e saber
onde estão todos. Então, vou
manter meu piso como eu estava. Eu acho
que isso é muito bom. Meu piso dois, eu vou
fazer um bem simples, só
vai ter um
único espigão no meio E então, no piso três, eu vou ter um
espigão duplo perto do final Como eu disse, você pode fazer
o que quiser com eles. Não precisa ser
exatamente o que estou fazendo. Deixe-me diminuir um pouco, mas esses são os três primeiros. Vou fazer
ladrilho ali, adicionar o espigão duplo.
Depois, ladrilho quatro, vou começar a adicionar
algo mais interessante Então, vou tirar
essa e colocar uma bola de
espinhos ali Eu acho que parece muito legal. Isso é para azulejos.
Piso. Quadro cinco. Acho que vou ter um espigão duplo no começo Então, talvez vamos adicionar uma
bola de espinhos aqui perto do final. Como eu disse, você pode realmente fazer o que quiser com eles. Você pode
acompanhar se quiser, mas na verdade não
precisa pavimentar oito. Acho que só vou
comer bolas de espinhos. Deixe-me me livrar
disso. Eu vou ter uma
bola de espinhos aqui. Talvez um ali embaixo, então você tem que pular por cima. Vamos ajustar
o roteiro de movimento à medida que avançamos no jogo
para garantir que isso sempre seja possível, pois
isso pode, na verdade, não ser um salto possível no estado
atual do jogo Lembre-se de que
você está sempre mantendo seus scripts o mais ajustáveis
possível , pois você
pode ajustá-los. Felizmente, com nosso
script, obviamente
adicionamos essas
variáveis aqui Altura de salto e velocidade de jogo. Podemos meio que ajustar o que
quisermos sobre o script por enquanto, mas podemos adicionar
outras coisas mais tarde Lembre-se de
que a chave para um bom desenvolvimento de
jogos, pelo
menos um deles, é sempre se
certificar de que você está adaptando
seu jogo à medida que avança Não seja pego tentando ficar com algo que não está funcionando antes de eu voltar
a criar mais pneus. Na verdade, vou
excluir esses três prefabs. E eu também vou realmente
mudar esse pré-fabricado. O que vou fazer
é fazer que chamamos de
desempacotar um pré-fabricado, o
que basicamente mostra
o jogo, que basicamente mostra
o jogo Na verdade, não quero mais
que seja um pré-fabricado. Eu quero que seja seu próprio objeto. Novamente, vou clicar com o botão direito do mouse em prefab e
selecionar descompactado E então eu vou seguir em frente e me livrar desses espinhos Agora eu tenho meu objeto
original de volta. Basicamente, o que
acabei de dizer à Unity é que,
embora eu tenha baseado todo o meu
prefab nesse objeto, quero fazer com que seja
seu objeto original Novamente, quero romper a ligação entre isso
e o pré-fabricado Eu ainda tenho todos os meus pré-fabricados, mas agora isso é apenas um objeto.
Novamente, não está vinculado. E você pode ver que passou
do azul para a cor normal. Novamente, vamos voltar aqui, fazer mais alguns ladrilhos. Acho que é bom ter
talvez outro com o dobro. Mova isso um pouco para baixo, então podemos ter uma
bola de espinhos logo acima dela Essas vão ser
muito difíceis lá. Isso é um pouco parecido com 45, mas acho que talvez
seja um pouco diferente. Então,
vamos mover isso para lá. Pode movê-lo, você precisa, é um pouco mais alto, então
é bem fácil, eu acho. Em seguida, ladrilho oito. Vou simplificar
um pouco. Novamente, esta na verdade
será apenas uma
bola de espinhos no meio Obviamente, vamos
editá-los à medida que adicionamos mais coisas, porque isso não é
muito empolgante por si só. Mas quando
jogarmos o jogo, obviamente teremos que passar
correndo para acompanhar a câmera. Até mesmo algo
assim pode ser um pouco mais interessante do que
realmente parece à primeira vista. Mas de qualquer forma, passando
para o piso nove. Vou tomar um spipal
no começo porque
acho que ainda não fiz isso Temos que passar por
baixo dela e
pular o piso dez. Vamos ter três pontas. Esses são todos os meus azulejos por enquanto. Eu tenho quatro com bolas de espigão, sem
bolas de espigão, e eu tenho seis
com bolas de espigão e todas elas têm
basicamente pontas , exceto Esses serão os blocos de
construção do nosso mapa. E quero dizer isso literalmente porque eles são, na verdade,
o que vamos
criar quando escrevermos
nosso script de geração de mapas Agora, se você seguir esta lição e
tiver um conjunto de blocos, isso é tudo que você precisa fazer. O que fizemos foi criar
nossos pré-fabricados inimigos aqui nossos pré-fabricados inimigos E agora também criamos
vários blocos pré-fabricados. Na próxima lição, vamos começar a escrever um
script que dirá,
ok, apareça
aleatoriamente nesses prefabs para que possamos começar
a gerar que possamos começar E depois de fazermos
isso,
vamos realmente adicionar um script panorâmico
da câmera. Ou talvez possamos fazer
isso primeiro, na verdade. Portanto, certifique-se de que a
câmera esteja continuamente girando e que o player acompanhe
a E isso basicamente
vai aumentar nosso jogo. Portanto, você precisa
se mover constantemente para manter toda
a câmera e evitar
esses obstáculos Então, tudo isso virá
no próximo vídeo. Mas se você
acompanhar tudo e tiver seus dez blocos, isso é ótimo e
começaremos a usá-los no
próximo vídeo. Obrigada.
6. 5. Gerando nosso mapa: Olá, e bem-vindo de
volta à Unity. Agora, no último vídeo,
obviamente, criamos todos os
nossos prefabs e todos os nossos diferentes objetos, nos
quais
apareceremos quando
começarmos a criar Mas agora precisamos realmente
escrever o código que
fará com que o Unity
apareça em nossos objetos Isso pode parecer uma tarefa
entediante e complicada, mas na verdade é muito
mais simples do que você imagina E vamos
dividi-lo em duas partes. A primeira coisa que
vamos fazer é escrever um roteiro
que basicamente diz
à câmera que se mova
constantemente
pela tela para que tenhamos algo
para o jogador seguir. Em segundo lugar,
vamos escrever um
script que basicamente determina que queremos
gerar coisas com base na
posição da câmera Em outras palavras, quando as câmeras aqui geram algo lá, e quando as câmeras
ali geram algo
ali, temos constantemente esses objetos que são gerados à medida que
avançamos Antes de me antecipar, vamos começar
fazendo aquele roteiro panorâmico da câmera. Vamos abrir os
scripts, nossa pasta. Vamos clicar com o botão direito do mouse em Criar um novo script C sharp
e vamos chamá-lo de movimento da câmera. Agora, na verdade, esse será um script incrivelmente simples. Serão duas linhas de código, ou até mesmo uma. Ou vamos primeiro
nos livrar desses dois
vazios e usar
a atualização fixa porque simplesmente
teremos usar
a atualização fixa porque resultados baseados em
física,
ou melhor, cálculos
e processos
baseados em física aqui E não vamos usar nenhuma entrada nem nada
para esse script. Tudo o que teremos
é esse vazio aqui, que obviamente percorrerá cada intervalo fixo em
torno de um quadro E vamos
criar duas variáveis. O primeiro deles
será
um corpo público de cordilheira dois D e
vamos chamá-lo de RB. Você não precisa se preocupar inventar nomes diferentes desde que estejam em scripts
diferentes, você pode usar os mesmos nomes. Obviamente, você não pode nomear duas
coisas, R B em um script, mas podemos usar o
mesmo nome R B aqui, mesmo que na verdade estejamos
falando sobre outra coisa. De qualquer forma, a segunda
coisa que teremos é um carro alegórico público, e vamos
chamá-lo de velocidade da câmera Todo o código que
precisamos aqui é na verdade, muito
semelhante ao código que escrevemos para o movimento do
jogador. Vamos fazer com que o corpo rígido
perca seu novo vetor dois. Vamos configurá-lo para a velocidade
da câmera e para zero. Na verdade, não precisamos
definir isso como zero, também
podemos configurá-lo
para o RB do losityty, mas como geralmente não queremos que nossa câmera se
mova para cima e para baixo, isso realmente não faz muita
diferença Vamos definir
esse zero, não importa. Você também pode simplesmente
configurá-lo para blosityy, porque você verá que, quando
configurarmos nosso corpo rígido, isso realmente não
fará nenhuma diferença, porque basicamente
faremos a câmera
não seja afetada pela Eu vou chegar a isso em um minuto. Mas, na verdade, esse é
todo o código que
precisamos para ter uma câmera que funcione conforme tornamos nosso jogo cada vez
mais complicado. Podemos corrigir isso e talvez fazer com que a câmera
acelere com o tempo. Nesse caso,
teremos uma variável que
aumenta com a distância. E então, a cada poucos metros, ou a cada poucas centenas de
metros ou qualquer outra coisa, vamos aumentar
a velocidade da câmera. Mas, por enquanto, isso
vai funcionar bem. Vamos voltar para o Unity e ir para o objeto principal
da câmera. Vamos arrastar nosso roteiro de
movimento de câmera para ele. Agora temos nosso corpo rígido
e nossa velocidade de câmera, mas na verdade não adicionamos um corpo
rígido a essa câmera principal Se tentarmos executar o script
, haverá um erro dizendo: Não
sei o que é
esse corpo rígido Você está tentando basicamente
se referir a isso dizendo, oh, defina nossa velocidade para isso, mas eu não tenho nada lá, então não posso realmente fazer isso Vamos precisar adicionar um corpo rígido
à nossa câmera e vamos adicionar um
componente de corpo rígido
dois D e clicar em Play Você pode estar pensando, bem, isso
não vai fazer com que
a câmera caia? E você estaria 100% certo. Na verdade, se agora
vamos ver que nossa câmera realmente
vai cair. Pode parecer
que tudo está subindo, mas a câmera está
realmente caindo. Você pode ver isso ir até lá, o que realmente
não é o que queremos, mas na verdade é uma coisa
muito fácil de consertar. Porque não
vamos usar
o mesmo tipo de corpo rígido
que usamos para nosso jogador Nosso jogador usa o que é
chamado de corpo rígido dinâmico. E isso é basicamente
um corpo Ridgid, que é afetado pelas
forças e pela gravidade e um monte de coisas
externas Há outro
tipo de corpo rígido, chamado corpo rígido
cinemático, que é influenciado É como um corpo rígido normal e
automatizado, de
uma forma que faz
coisas por você Ele cai no espaço livre. Ele sabe quando
parar e sabe
quando se mover e deslizar. Obviamente, você pode
adicionar mais movimento a isso, como fizemos
aqui, como fizemos, ok. Ao clicar nesse botão,
mova-se nessa direção. Mas, obviamente, também faz um
monte de coisas para nós, especificamente a queda e
o movimento antes de
adicionarmos qualquer codificação Agora, se eu for para minha câmera principal, não
quero isso para isso. Eu quero que essa câmera só se
mova quando eu mandar ela se mover. Especificamente, como em um script, podemos ver aqui a variável R B do
movimento da câmera não foi atribuída, foi o erro que
apareceu
aqui e obtivemos
cada quadro, que é o que eu
disse que aconteceria Para corrigir isso, o que
vamos fazer é mudar
esse tipo de corpo para o que é
chamado de crista cinemática O corpo pode ver que, no
minuto em que fazemos isso, todas essas variáveis massivas
em uma escala de gravidade de arrasto desaparecem instantaneamente. Porque um corpo rígido cinemático não
é afetado pela
gravidade ou por Ele só se move quando
eu digo para ele se mover. E vamos seguir em frente
e arrastar isso para o meu roteiro. Agora o que eu tenho é um
corpo rígido que é como um corpo rígido que
é totalmente manual, então eu tenho que dizer, ok, eu quero que sua velocidade seja essa, assim como eu fiz
aqui Defina a velocidade para essa velocidade
variável da câmera. Quando eu mudo essa velocidade
variável da câmera, ela realmente
muda a velocidade Você vê uma ação aqui. Se eu clicar em jogar, ele
carregará meu jogo
e, no momento, está definido como zero. Acho que clico em jogar duas vezes.
Vamos clicar nele novamente. Clique. No momento, está definido como zero, então
não se move. Mas se eu definir isso como um, podemos ver a câmera
lentamente começar a se deslocar. Se eu disser menos um, vou me mover
na mesma direção Se eu definir algo como cinco, você pode ver que eu vou muito mais rápido. E menos dez, eu retrocedo. Obviamente, você pode editar
isso para ser o que quiser. Vou começar
com uma velocidade básica de pânico de três porque acho que
será bom para começar, especialmente enquanto estou desenvolvendo
meu jogo, como você disse, obviamente
você pode ajustar
todas essas coisas Agora, isso na verdade
pode ser um pouco rápido. Vou fazer esse 1.8
que parece muito melhor para mim. E você pode ver agora que eu posso
acompanhar junto com a câmera. Obviamente, ainda não consigo
dar esse salto, mas basicamente agora temos um
roteiro que diz à câmera:
ok, avance nessa velocidade. Isso é tudo, mas
não temos um mapa para gerar. Na verdade, não
sabemos onde desovar e não sabemos para
onde pular
porque não podemos A primeira coisa que quero fazer é mover isso
para lá. Porque eu realmente não quero
que seja um mapa impossível, especialmente se for
a primeira coisa que
você encontra ao jogar. O que vou
fazer agora é começar
a escrever código, que basicamente dirá à câmera ou
a qualquer
objeto que eu quiser, mas vou usar a câmera para gerar certos objetos No minuto em que alcanço um
determinado comprimento, em um determinado intervalo, quero aparecer em um objeto E a maneira de
fazer isso é observar o
comprimento dos meus objetos, ir até os pré-fabricados abertos e ver a que
distância meus objetos Vou começar
limpando
alguns desses
pneus de chão que eu tinha originalmente, não permanentemente, mas
vou clicar em três
deles e clicar
no pequeno ícone neles Eles estão escondidos da tela. Na verdade, não
preciso selecioná-los, isso não faz diferença. Mas eu acabei de
escondê-los por enquanto. Eles ainda estão lá, mas eu não quero que eles estejam na minha tela. Você pode ocultá-los ou
mostrá-los usando um pequeno ícone. Na verdade, você pode esconder
a cena inteira se quiser, mas
não queremos fazer isso. Eu só quero esconder meus
três objetos do chão. O que vou fazer é adicionar novos objetos. Eu quero um objeto por lá. Acho que quero que os
objetos espaçados sejam desse tamanho. Vamos ver se eu
tenho meu primeiro objeto. Vou defini-la como
uma posição mais fácil. Vamos fazer com que seja menos 6,5 Eu vou fazer meu novo
objeto 1,5 Veja aqui Agora temos dois objetos que estão bem uniformemente espaçados. Vamos adicionar outro
aqui e vamos fazer isso 19,5. Adicionamos mais um depois disso Vamos adicionar o piso sete, e então talvez o
piso oito,
podemos fazer 17,5 Podemos fazer 25,5
Podemos ver que temos
menos 6,5 , então temos
1,5, então temos 9,5 , temos 17,5 e temos
25,5. Podemos ver que queremos eles estejam separados por cerca de oito
unidades, então vou E eu vou dizer que a cada oito unidades que
a câmera move, eu vou querer aparecer em um novo objeto porque isso significa que eu terei me movido em torno de
uma dessas coisas A maneira como vou
fazer isso é criar um novo script. E eu vou chamar
isso de geração de mapas. No minuto em que
o script for mutilado, vou
clicar duas vezes para abri-lo É aqui que vou
realmente criar a lógica para aparecer em meus diferentes objetos Vou começar
criando um novo vazio público. Vou
chamá-la de spawn map piece. O que esse método
fará
é basicamente
pegar uma das peças aleatórias
do mapa
que projetamos anteriormente e
inseri-la no meu jogo Agora, a forma como vou
obter uma parte aleatória do mapa é criar uma
estrutura de dados conhecida como matriz. Esse é um conceito de codificação bastante
avançado. Na verdade, é
bastante rudimentar. Mas em termos do
que
já abordamos , é um grande salto Portanto, não vou
explicar exatamente como funciona e todos os seus usos. Basicamente, você pode
pensar nisso como uma lista. Eu tenho tipos de dados, quais você já
falou. Como se eu quisesse armazenar números, eu os coloco em um número inteiro Se eu quiser armazenar
muitas coisas, sejam muitos
números ou muitas palavras, eu as coloco no que é
chamado de matriz ou lista. E a maneira como você declara uma
matriz é se tornar pública, digitando o tipo dados que
deseja na sua lista Na verdade, quero objetos do jogo
porque os objetos do jogo, como mencionamos anteriormente, são
os blocos fundamentais do nosso jogo E todos esses ladrilhos
que fizemos são na verdade, exemplos de objetos,
embora sejam pré-fabricados Então, eles são como modelos de
objetos. Eles ainda são do tipo de objeto de
dados. Para mostrar que é uma lista
e não apenas um jogo. eu vou adicionar esses dois colchetes depois, que diz à Unity, ok, isso não é uma coisa,
é uma lista de Vou chamá-lo de blocos de mapas. Agora, é basicamente aqui que
vou armazenar todos os blocos
do meu mapa. Se eu voltar para o Unity e
voltar para minha câmera principal, vou ver aqui, se eu arrastar meu script de
geração de mapas, vamos colocá-lo acima
do corpo rígido e vamos realmente mover o corpo da
crista para lá Veja, agora eu tenho
esses blocos de mapa e atualmente não tem nada
nele. Diz que a lista está vazia. Mas vou
começar a preenchê-lo. Vou colocar dez
coisas na minha lista. Então eu vou mudar
esse número dez. Vou adicionar os dez blocos de mapas que
criamos anteriormente. Vamos aos
ladrilhos pré-fabricados e apenas colocar no piso um piso,
dois ladrilhos três,
ladrilho quatro, etc.,
etc Até que tenhamos
todos os ladrilhos que acabamos de
criar nesta lista, será assim que
os geraremos aleatoriamente Não se preocupe
exatamente com o funcionamento dos raios. Como eu disse, como se houvesse
algumas coisas complicadas, especialmente se você
já codificou antes,
como se elas começassem no índice zero, esse é na verdade o elemento
nove, mesmo sendo especialmente se você
já codificou antes,
como se elas começassem no índice zero,
esse é na verdade o elemento
nove, mesmo sendo
o Elemento. Obviamente,
esses objetos do jogo, o conceito real
de variáveis e todas essas coisas podem
parecer um pouco confusos, especialmente se você
nunca programou Mas pense nisso
como uma lista de objetos. Abordamos o que são objetos, os blocos de construção
são nossos jogos e temos uma lista
de modelos de objetos, nos
quais vamos gerar Basicamente, estamos dizendo, ok,
todos esses arquivos que criamos, coloque-os na estrutura de dados,
que é chamada de matriz. E vou escolher um
dessa matriz aleatoriamente toda vez que quiser gerar
um e colocá-lo no meu jogo A próxima coisa que preciso fazer é realmente escrever
o código para fazer isso. Vamos voltar ao
meu código aqui. E eu vou dizer que escolha um membro aleatório da minha
matriz e gere-o A maneira como vou
fazer isso é a seguinte. Eu vou dizer bloco de objetos de
jogo. Então, eu tenho uma nova variável local que é como um espaço de armazenamento
local. Só é acessível
dentro desse método. Não preciso colocá-lo aqui, mas é melhor
para o desempenho porque não preciso que ele
esteja acessível em nenhum outro lugar. Eu só preciso dele aqui,
digamos que seja igual a blocos do mapa. Agora, para acessar um elemento específico da matriz, eu uso
colchete. Então isso quer dizer, ok,
abra o primeiro. O que esse código
fará é dizer,
ok, pegue o primeiro
elemento nos blocos do mapa, que é o piso um, e coloque-o nos blocos do espaço
de armazenamento. Mas eu não
quero ser apenas o primeiro, quero ser aleatório. Para fazer isso, vou
usar um intervalo aleatório, vou usar um intervalo aleatório. O que isso basicamente
vai fazer é me permitir
escolher um número aleatório de
um intervalo especificado, como
você provavelmente pode
adivinhar pelo nome que abrirá parênteses E agora precisamos de um
mínimo inclusivo e um máximo inclusivo. Agora, eu não sei exatamente por que
eles dizem máximo inclusivo, porque o intervalo aleatório de 1 a 2 na verdade,
retornará apenas o número um. Acho que a razão pela qual
dizem inclusivo talvez esteja
se referindo a flutuações, mas com números inteiros,
na verdade, não é inclusivo para o valor superior, mas apenas
para o valor inferior Vamos até aqui e vamos definir o valor inferior como zero, que é, como dissemos, o primeiro
elemento da nossa matriz, que aqui é o
piso um. Mas queremos que seja qualquer
um desses elementos. E poderíamos simplesmente entrar do elemento zero
ao elemento nove. Poderíamos simplesmente inserir
algo assim. Obviamente, como eu disse, não
é inclusivo. Teríamos que colocar
dez ali. Mas isso realmente
vai funcionar perfeitamente bem para nossos propósitos. Isso precisa ser
um colchete,
não um colchete redondo, porque
estamos nos referindo a uma matriz E uma matriz, você usa colchetes para dizer a qual
índice você está se referindo De qualquer forma, isso funcionaria
perfeitamente bem para nossos propósitos, porque
você escolherá um número aleatório
todas as vezes. Chamamos isso de zero
até nove. Mas a razão pela qual não
queremos codificá-lo dessa forma é o que é conhecido
como codificação rígida, que você insere valores exatos em vez do que é conhecido como,
eu acho, valores dinâmicos ou
variáveis A razão pela qual não queremos
fazer isso é porque,
digamos que decidimos adicionar um
monte de pneus novos. Nós os adicionamos à nossa matriz. Temos que voltar e alterar esse código
em vez de atualizá-lo automaticamente para incluir todo
o comprimento da
matriz, que é o que queremos. Em vez de usar dez,
vamos
mapear o comprimento dos pontos dos blocos. O comprimento do ponto do bloco do mapa, na verdade nos dará o
número dez aqui, porque podemos ver que temos dez
elementos diferentes aqui. Os blocos do mapa têm um comprimento de dez. Acho que essa talvez seja uma
das razões pelas quais o
índice começa em zero porque esse comando de intervalo obviamente não
incluirá esse limite superior E nunca vamos
realmente
tentar acessar o
décimo elemento, que nos daria um erro porque
não há décimo elemento, há apenas um nono
até o até No começo, é um pouco
confuso, mas você deve conseguir
obtê-lo quanto mais usar matrizes E é uma convenção
em ciência da computação, acho que você também se acostuma com
isso depois de um tempo. Mas, independentemente disso, esse código
aqui vai dizer, ok, me dê qualquer elemento
em toda a matriz. Pode parecer um
pouco confuso, mas basicamente tudo o que estamos
fazendo é dizer, ok, temos essa lista de coisas
e, no índice específico, do menor índice até um mais
o maior índice, que nos levará
até o maior índice Me dê um índice a partir daí. Isso nos dará agora uma peça aleatória a cada
vez, que é a metade. O que precisamos fazer
agora, tudo o que precisamos
fazer é realmente
aparecer naquele bloco Então, vamos dizer
instanciar o bloco como objeto do jogo. Essa linha de código aqui é basicamente o que
vamos
usar para gerar em nosso prefab Então, estamos dizendo, ok,
eu tenho essa gravata aqui agora e
quero colocá-la no meu jogo. Mas podemos ver aqui que recebemos uma mensagem de erro
que diz, ok, apenas a chamada de
atribuição incrementa, diminui um peso. E novas expressões de objetos
podem ser usadas em uma declaração. O que é basicamente como dizer que
temos metade de uma afirmação aqui, temos igual a cinco,
não temos o outro lado Então eu estou dizendo, ok, eu quero
instanciar como um objeto do jogo, mas o que eu quero
fazer com isso? Teremos que armazenar
isso em outra variável. Chame isso de bloco do mapa de objetos do jogo é igual a instanciar o
bloco Isso não é muito
parecido com o código necessário. Nós realmente não precisávamos
dessa variável porque
poderíamos simplesmente pegar
isso e colocá-lo lá. Mas vou
explicá-lo assim só porque o torna um
pouco mais agradável de ler Primeiro, temos esse bloco de objetos
do jogo, que é um bloco aleatório. E então vamos
instanciar esse bloco e
vamos chamá-lo de bloco de mapa
ou melhor, de bloco de jogo O bloco real pode muito bem mudar
o nome para bloco gerado. Podemos diferenciar
entre o que
iríamos gerar e, uma vez que realmente o
geramos, agora estamos nos referindo ao objeto
real criado,
não ao prefabricado. Então
esse é o prefab O objeto real que ele fez. E precisamos adicionar algumas coisas. Antes de tudo, precisamos
mudar sua posição. Na verdade, isso é
tudo o que precisamos adicionar, porque agora ele
vai gerá-lo, mas não sabemos onde ele
vai gerá-lo,
queremos mudar
sua queremos mudar Vamos fazer isso alterando
essa variável, um bloco gerado Vamos aparecer lado a lado, a posição
transformada é igual. Em seguida, vamos tomar a posição
atual da nossa câmera. Podemos fazer isso usando um objeto de jogo em
minúsculas, que diz, ok, consulte o objeto do jogo ao qual esse script está
atualmente anexado, que será a posição de transformação
da nossa câmera. Basicamente, isso significa que, ok, defina nossa
oposição transformada de nosso bloco de desova exatamente
onde a câmera está Na verdade, não queremos que esteja exatamente onde a câmera está, queremos ser
um pouco diferentes. Vamos criar um novo vetor três. Isso quer dizer que
queremos armazenar três coisas. Teremos x, y e z. Vamos definir a posição de
transformação do objeto do jogo
para a posição atual da
nossa câmera mais um pouco de deslocamento E criaremos uma nova variável,
public float offset X, public float offset X e a adicionaremos à posição atual de nossos jogadores em vez da posição
atual de nossas câmeras Agora, o que vou fazer
é dizer, ok, apareça em um ladrilho e coloque-o onde quer que minha câmera
esteja, além de uma posição Então isso deve ser bom o suficiente. Mas queremos, lembre-se de
que também não o
queremos na
posição Y de nossa câmera, porque nossa câmera
provavelmente terá uma posição Y em torno de
zero. E queremos que esteja na metade
inferior da tela. Não queremos ficar no meio
da tela, então vamos criar uma nova posição para
aparecer em nossos objetos, mas queremos saber quais devem ser
os limites
disso E para fazer isso,
vamos
voltar direto para o editor Unity. Vamos ver, ok,
onde deveria estar. Vou analisar
isso e vou
examinar esses valores y e decidir que acho que quero que meu objeto
esteja em qualquer lugar, digamos, -4,5. Acho que é quase o mais baixo.
Quero até -3,5, talvez não pareça muito,
mas é uma quantidade bastante
variável de espaço,
especialmente para nossa
pequena altura de salto Podemos mudar a altura do
salto mais tarde, mas acho que isso é bom por enquanto. Vamos definir
isso para menos quatro. Não me lembro
exatamente o que era, mas acho que estava em torno de -3,9 Agora vamos usar outra declaração de intervalo
aleatório
para dizer basicamente,
ok, em qualquer lugar entre
esses dois pontos, vou usar esses pontos
na verdade como variáveis Novamente, public float
min Y e max Y, que vamos atribuir
no editor Unity, que veremos mais tarde Mas vou dizer, ok,
quero que minha posição Y esteja em qualquer lugar
desse intervalo aleatório, assim como usamos anteriormente. E vou dizer que vou até
o máximo Y. Por fim, podemos simplesmente definir sua posição zero porque estamos
usando um jogo de dois D. Agora, o que isso vai fazer
é dizer, ok, toda vez que chamarmos
essa peça do mapa de desova, vamos gerar
uma nova peça do mapa E queremos gerá-lo
onde quer que estejamos em nosso jogo. Além de um offset X,
que descobriremos enquanto jogamos o
jogo experimentalmente Vamos
descobrir isso agora. E queremos um intervalo aleatório de -4,5 a 3,5, que
também vamos adicionar agora Agora, a última coisa que vou
fazer antes de voltar para Unity é basicamente
permitir que eu teste o script. Eu vou dizer que se a entrada
obtiver a chave no espaço do código de tecla, então chame minha peça do mapa de spawn Eu não adicionei o
código aqui novamente. Isso é a mesma coisa
porque é apenas uma linha de código. Na verdade, você não precisa
deles, mas pode dividi-los se quiser e apenas
garantir que estejam dentro desse bloco. Mas só para constar, ter uma linha recuada
é exatamente a mesma coisa Parece um pouco mais
organizado aqui,
estamos dizendo ok, toda vez que clico na barra de
espaço, executo esse código Na verdade,
isso nos permitirá
testar nosso script de geração de mapas. Para garantir que funcione, vamos
voltar direto para o Unity. Vamos ver, diretamente no
nosso roteiro de câmera principal. A primeira coisa que
queremos fazer é configurar esse deslocamento
em termos de deslocamento Acho que vai ser
que, se eu for até aqui e movê-lo, vou querer
gerá-lo por lá São cerca de 15 horas de
câmeras em zero. Então, acho que
vai estar por aí. Mas, obviamente,
poderei
configurar isso à medida que prossigo. Acho que foi 6,5 Vamos definir
esse deslocamento y para Queremos que nosso mínimo Y seja -4,5 max y seja 3,5. Vamos
ver se isso funciona Vou começar sem
mover minha câmera,
só para ver
se a desova
realmente olha ao redor de onde
eu quero que realmente olha ao redor de onde esteja à frente da qual
vou bater Você pode ver que, na verdade,
quando clico no
meu jogo, meus três andares que eu
atingi antes ainda estão
aqui. Voltamos lá e
excluímos esse piso. E eu tenho isso como
eu tinha antes. Na verdade, vou
movê-los um pouco. Eu não tenho. Parece que
eles se adaptaram. Não tenho certeza do porquê. Interessante. Independentemente disso, vamos
continuar e clicar em Jogar. E então vamos ver o que
acontece se clicarmos
na barra de espaço.
Voltamos à nossa cena. Podemos ver, ok, na verdade
temos uma coisa aleatória surgindo, o
que é ótimo Queremos, se a afastarmos, clicar em uma barra de espaço novamente, teremos uma
coisa diferente surgindo E isso realmente parece
muito perfeito para mim. Se eu clicar várias vezes, eles realmente têm altura
variável. Então, alguns deles estão desovando um pouco
mais do que os antigos, e temos
coisas diferentes desovando, o
que é perfeito, isso é
exatamente o que queremos que é perfeito, isso é
exatamente A última coisa que precisamos
fazer agora é
garantir que isso
aconteça automaticamente. Desde que a câmera
se mova a cada oito unidades, queremos gerar uma nova Então, a maneira como eles
vão fazer isso vai voltar
direto para o nosso código. E a primeira coisa que
vamos fazer é nos livrar desse código de teste porque você não
quer aparecer em nossos ladrilhos toda vez que
cozinhamos a barra de espaço, queremos aparecer toda vez que
percorremos uma certa distância A primeira coisa
que vamos fazer é criar
algumas variáveis de movimento. Vamos criar um carro alegórico público e chamaremos de Spawn Position Isso vai
rastrear exatamente onde,
no plano X, geramos
nossa última peça do mapa Então, vamos seguir em frente com nosso vazio
inicial e
gerar uma peça do mapa Isso é básico, digamos que,
logo no início do jogo,
verifique esses parênteses ao chamar um bloco de
código
específico no início do jogo,
antes mesmo de começar a jogar
Spawn em uma peça Porque podemos ver
se vamos para o Unity, na verdade não
temos
nada sobre isso. Queremos fazer isso no
minuto em que aparecermos. Mas a última coisa que
faremos para garantir que saibamos gerar uma nova
toda vez que precisarmos de uma é ir até a
variável de posição de desova e
configurá-la para nossa posição de transformação
atual x. Essa é basicamente
uma forma abreviada de
dizer objeto de jogo
transformar posição X. Na verdade, não
precisamos dessa coisa de objeto Na verdade, não
precisamos aqui porque usar
uma letra minúscula se refere
à transformação anexada a esse objeto do jogo
que você vê aqui. Se passarmos o mouse, isso
explica isso para nós. Isso quer dizer, ok, defina nossa posição de
desova atual para o
ponto de oposição transferido X do nosso objeto de câmera No minuto em que aparecermos
em um pedaço do mapa, acompanhe onde o
geramos no plano X. Em seguida, adicionaremos nossa declaração
if à nossa placa vazia Diremos minha posição atual
menos minha posição de desova. Em outras palavras, se meu deslocamento
de onde
estou atualmente para onde nasci pela última vez, minha última peça
for maior que oito Em outras palavras, se eu movi oito unidades desde que
gerei a última peça, é hora de gerar uma nova Temos que escrever
se meu ponto
oposto transferido x
menos a posição de desova, colocar parênteses ao redor deles é maior Em outras palavras, se tivermos movido oito ou mais peças
, queremos chamar
nossa peça do mapa de desova Obviamente, isso redefinirá nossa posição de spawn para minha posição de transferência
atual para X. Então, na próxima atualização, essa não
será mais oito Se tudo estiver
escrito aqui corretamente, ele deve aparecer em cada oito
peças em uma nova peça do mapa, e devemos ver
isso em ação Ou você volta ao jogo. Vamos
clicar nele, para
garantir que tudo esteja
configurado,
pois precisamos voltar para 1.8.
Vamos acompanhar a variável de
posição de desova ao clicarmos em reproduzir Vamos em frente e aperte o play. Veja o que acontece ao longo do tempo, parece que nosso primeiro ladrilho
apareceu perfeitamente bem E, na verdade, se
olharmos em frente , podemos ver que está surgindo
exatamente como precisávamos Entramos na
visualização da cena, podemos realmente ver esses ladrilhos sendo
feitos à medida que avançamos, no momento perfeito. Aqui, um novo estilo
surge
exatamente como precisávamos, um
minuto antes de
chegar à tela Temos nosso novo
bloco ali
e, obviamente, os jogadores
estão ficando um pouco para trás aqui. Mas, na verdade, podemos
ver que isso está criando um mapa de
geração automática muito legal. E isso realmente será
o coração da nossa
plataforma, um jogo. Obviamente, vamos
mudar isso e adicionar muitas coisas novas e legais, objetos
e
modelos diferentes à medida que
entramos em nosso jogo. Mas esse
será basicamente o modelo de como vamos começar a criar nosso jogo e como
tudo vai funcionar. No momento, criamos
a base para
o que é
um sistema muito legal para aparecer em blocos e criar um mapa de geração automática Agora, a última coisa que
precisamos fazer é ter certeza de que
realmente excluímos os blocos que
não estamos mais usando. Se prosseguirmos e clicarmos em play, podemos ver que podemos aparecer em blocos muito bem. E eles
realmente funcionam perfeitamente. Podemos ver lá, eles são
criados aqui, mas na verdade nunca desaparecem. À medida que isso continua,
se eu aumentar a velocidade, isso
também funcionará porque se
baseia na posição,
não em nada a ver com o tempo Então, podemos realmente ver que
criamos mais e mais peças, e tudo funciona perfeitamente. Mas esses ladrilhos estão
aqui e estão realmente entupindo minha cena E eu realmente não
quero que eles estejam lá. Depois de um tempo, o que
vou fazer é adicionar mais
uma linha de código, que vou
anexar aos blocos. Vou ter
uma pequena linha de código em cada bloco que diz que, se eu estiver tão
longe da câmera,
posso me destruir. Vamos medir o
que isso não deveria ser. Acho que no minuto em que
os ladrilhos estão por aqui, eles provavelmente deveriam ser
destruídos. Atualmente, está na Exposição
111.8 Digamos que seja 112 e a câmera esteja às
01:20 Digamos que seja 130, digamos que no minuto em que estejam
18 unidades atrás da câmera, elas podem se
destruir E esse é um roteiro incrivelmente
fácil de escrever. Vamos clicar com o botão direito do mouse,
criar script nítido em C, vamos chamá-lo de tile clear. Vou adicionar isso
a cada bloco, clique
duas vezes para abri-lo. E precisaremos apenas de
uma variável aqui, que na verdade será uma referência à nossa câmera principal. Então, vou criar
uma transformação pública. Na verdade, isso se refere
a um objeto do jogo, mas estou dizendo que só preciso da posição, da rotação e da escala
do objeto do jogo. Vou referenciar minha
câmera nessa variável, mas quero apenas sua posição.
Eu não preciso de mais nada. Ligue para isso. Agora, o importante a observar é que
geralmente atribuímos essas transformações no editor
do Unity Se a arrastarmos para o nosso
pré-fabricado e dissermos,
ok, eu quero aquela câmera Mas o fato é que, como os prefabs não são realmente
objetos no jogo, eles são tecnicamente
arquivos em nosso programa, não
podemos realmente fazer
a mesma coisa aqui Na verdade, quero
arrastar o script para
cada um dos meus pré-fabricados Então, posso fazer isso
acessando cada um dos meus prefabs e clicando em
Adicionar componentes,
e nosso nome, como eu o
chamo, fica limpo. Este script transparente
para cada um
deles . Apenas faça isso rapidamente. Eu acredito que você pode realmente
fazer isso várias vezes, uma vez que, se você selecionar todas
elas e depois adicionar a limpeza de blocos, ela deverá ser adicionada a
cada uma
delas . Acho que funcionou. Você pode ver que cada um
deles tem esse script de limpeza de blocos agora anexado, o que
é muito legal. Mas o problema é
que não podemos realmente referenciar essa câmera porque,
como eu disse,
essa câmera está procurando por um objeto
e não podemos arrastar a câmera porque
é um objeto de arquivo. Você precisa escrever algum código para descobrir isso. É bem simples. Vamos dizer que cam é
igual ao objeto do jogo. Encontre, chame de câmera principal porque é assim
que se chama. E isso vai dizer que no
minuto em que eu entrar no jogo, no minuto em que eu começar a existir, encontre a câmera principal, que
temos aqui, e a atribua a essa variável. É basicamente como se o tivéssemos
arrastado como antes. É apenas uma
maneira diferente de fazer isso. E eu vou em frente
e vou me transformar, porque eu só preciso da
transformação desse objeto do jogo. Então, o último trecho
de código que
precisamos dizer que
basicamente me destruo quando estiver longe é dizer
se minha posição transformar a posição ponto x menos
a posição da câmera Em outras palavras, posição da câmera x. Dizemos que se eu estiver
mais de 18 unidades atrás, se minha posição for zero e
a posição da câmera for 18, eu vou ficar
menos 18 para dizer que
é menor ou igual
a menos 18. Na verdade, eu poderia escrever isso ao contrário e dizer que se a posição da câmera menos
minha posição for maior que 18, se o deslocamento for maior, isso é exatamente a mesma coisa Então eu vou dizer
destrua o objeto do jogo. Em outras palavras,
me retire da cena. Na verdade, esse é todo o
código de que
precisaremos para resolver o problema sobre o qual
estamos falando antes. Antes de fazer isso, há mais uma coisa
que vou fazer aqui. E
será uma solução muito simples. Vou criar uma
nova transformação pública. Vou chamá-lo de
armazenamento de azulejos aqui embaixo. Depois de criar meu bloco de desova, o
bloco de geração se transforma. Defina pai, o que
basicamente significa, ok, defina o objeto pai. Vamos usar uma
pasta exatamente como usávamos
no passado e vamos configurá-la
para armazenamento em blocos. Isso basicamente
vai dizer, ok, no minuto em que eu fizer meu novo objeto, coloque-o embaixo
desse objeto vazio, que vou criar agora,
chame-o de armazenamento de blocos de mapas Vamos configurá-lo para zero aqui. Isso vai ser o onde
vamos colocar todos
os nossos objetos nisso. Vamos voltar para a
câmera principal e arrastá-la até
aqui para o armazenamento de blocos para que tenhamos nossa nova transformação. Por fim, a última coisa que
vamos fazer é
garantir que nosso script de
geração de blocos funcione Em vez disso, exclua o script. Vamos continuar e clicar em play. E devemos ver tudo
funcionar exatamente como está. Veja aqui, ele foi
colocado em um depósito de azulejos,
o que é ótimo. E vamos ver o que
acontece à medida que avançamos. Temos todos os nossos
novos ladrilhos disponíveis aqui. Este bloco aqui tem
o script de limpeza de blocos. No minuto em que estiver a uma certa
distância da câmera, ela deve realmente se excluir e deixar de existir.
Eu acho que vai. Aí está. Isso realmente
funcionou muito, muito bem. Essa será a base
do nosso jogo. Podemos fazer esta câmera
tão rápido quanto você quiser. Isso realmente não
faz diferença. Podemos ver exatamente como
isso vai funcionar. É assim que o jogo
vai ser jogado. Teremos
todos esses ladrilhos que estão sendo feitos ranoalmente Você pode ver
que alguns têm duplicatas, mas essa será
a essência do Vá em frente e jogue, pare. E eu disse isso a uma velocidade um pouco
mais empolgante, tipo três, e
apertei o play novamente. Eu posso ter uma ideia de como será
o jogo quando eu estiver
jogando, à medida que eu avance. E eu sempre vou
ter que me esquivar certas coisas e jogar como Então, essa será a
base do meu jogo de plataforma. Obviamente, vamos
adicionar sprites e fazer com que pareça muito mais
interessante e empolgante Mas é com isso que estamos
trabalhando no momento. Eu não acho que vai
ser tão rápido porque isso é, hum, eu acho, intenso, especialmente para um jogo que também
terá coisas como moedas e inimigos mais
complicados. Mas essa será a essência
que será a base do nosso script de geração de
mapas
7. 6. Adicionando sprites: Olá, e bem-vindo de
volta à Unity. Nas últimas aulas, criamos o que é
basicamente a base de uma
plataforma, um jogo. Criamos um
personagem que pode se mover. Criamos um mapa que
pode ser gerado aleatoriamente. E temos obstáculos
que podemos evitar. E temos uma câmera que
está continuamente girando, que temos que acompanhar Isso é praticamente
tudo o que
precisamos para criar uma plataforma básica, um jogo como já
fizemos, mas faltam algumas
coisas. Em primeiro lugar, você pode se deparar os obstáculos e
nada acontece. Em segundo lugar, a câmera na verdade
não faz
você ficar com ela. Você pode sair e voltar para dentro. Não há penalidade por isso. Em terceiro lugar, e quase
o
mais importante, o jogo não parece ótimo. Temos um quadrado, pulando em outros
retângulos e evitando
triângulos e círculos que
são amarelos, brancos É isso mesmo. Você pode criar
um jogo com formas. Na verdade, já fiz isso algumas
vezes no passado, mas para essa plataforma específica, por ser um jogo de plataforma
intermediário, achei que seria bom usar sprites e vou
usar pixel art agora, todos os sprites que
vou criar para o
meu projeto serão
vinculados ao longo deste curso Você pode encontrar todos eles como links
para download à medida que eu
avança e importo novos arquivos Qualquer arquivo que eu use em
todo o projeto, você também deve
conseguir encontrar. Eu fiz um monte
de sprites para este jogo. Se você quiser usar os mesmos
sprites que eu estou usando, basta baixá-los na descrição
deste vídeo
ou, abaixo do curso,
você pode encontrar um link para os downloads
deste vídeo Agora, como eu disse, você não
precisa usar meus sprites. Você pode usar seus próprios sprites ou pode usar quadrados
e Isso realmente não
faz diferença. Mas se você quiser acompanhar e usar os sprites que estou usando, precisará baixar obviamente precisará baixar esses arquivos Você pode usar
os mesmos. Dito isso, como eu disse, você não precisa usar os mesmos sprites que eu. Mas é importante
observar que os sprites
determinam , de várias maneiras como vamos
equilibrar nosso jogo Por exemplo, se
tivéssemos os sprites que vou
usar, seriam menores e nuvens Então, vou querer
ajustar algumas coisas
sobre o jogo Talvez eu o
faça pular mais alto. Queremos deixar
o spawn mais
distante apenas para que
pareça mais com nuvens E esse tipo de ajuste
que podemos fazer porque
temos variáveis em nossos scripts que nos permitem controlar isso Como se tivéssemos uma
altura de salto aqui e uma distância de desova para
os formulários aqui Obviamente, você não
precisa copiar meus valores exatos. Mas se é a primeira vez que você codifica e
cria Unity e cria um jogo, eu recomendaria me
acompanhar enquanto eu importo sprites e uso os
mesmos sprites que estou usando, talvez
os
mesmos Porque vai
tornar um pouco mais fácil comparar
seu jogo com o meu. E você ficaria
surpreso com a quantidade pequenos
ajustes que podem
fazer com que um jogo pareça diferente Você não precisa fazer
exatamente o que eu estou fazendo. Você não precisa usar
os mesmos sprites, eu sou. Mas eu recomendaria se você
quisesse fazer o mesmo jogo. Talvez eu use os
mesmos sprites e talvez apenas os ajuste da mesma forma que uso,
porque parecerá praticamente o mesmo Como se você não quisesse ficar
preso a um jogo semelhante. Isso não é realmente
o que você queria. Com tudo isso
dito, como eu
disse, a decisão é totalmente sua. Mas vou começar a
usar meus próprios sprites. Vou descer até a pasta
do projeto, clique com o botão direito do mouse. Vou criar uma pasta e vou
chamá-la de sprites Agora, existem algumas maneiras de
colocar sprites em seu jogo Sprites são na verdade apenas arquivos, são
representações visuais de objetos, é
como eu gosto de chamá-los. Na verdade, temos alguns prontos. Como se tivéssemos um sprite
quadrado lá
e sprites retangulares Bem, na verdade são apenas sprites quadrados
esticados. Mas queremos algo
um pouco mais interessante. Precisaremos
importar arquivos para o nosso jogo. Há algumas maneiras de
fazer isso. Você pode clicar duas vezes
na pasta sprites e importar o Novo Ativo Você pode abrir o
Explorador de Arquivos e arrastá-los para
essa janela aqui. Ou você pode realmente acessar
o Explorador de Arquivos, descobrir onde seu jogo está salvo e simplesmente copiá-los para essa pasta específica que
você acabou de criar. Essa não é a
melhor maneira de fazer isso. Eu recomendo que você escolha
um dos dois primeiros. Eu mencionei apenas porque a forma como o Unity funciona é quando
você importa um arquivo, ele cria outro arquivo
que precisa ser chamado de metarquivo Para cada
arquivo que você importa, digamos que você importe
algo p quatro, ele criará algo meta
ou algo p quatro domTai,
não tenho certeza
exatamente como ele o chama, mas basicamente
cria um metáfilo Sem precisar
entrar em muitos detalhes, é como o Unity funciona
com arquivos importados Ele precisa que ele
funcione corretamente. E essas metáfilas são criadas
automaticamente quando você importa seus
arquivos Mas se você não tiver o Unity
aberto, ou mesmo se tiver, e fizer isso diretamente
com o Explorador de Arquivos
, ele não
criará esses arquivos para você. O Unity faz um
ótimo trabalho ao
criá-los automaticamente no lançamento
e coisas assim, mas apenas para evitar qualquer
problema que possa surgir, recomendo que você
importe seus arquivos usando essa importante nova janela de
ativos aqui Vamos entrar em nossa pasta.
Vamos importar um novo ativo. Vamos colocar esses
quatro ativos de sprites que, como eu disse, estão todos obviamente
vinculados abaixo do vídeo,
então você pode simplesmente
importá-los para o seu jogo Há algumas coisas que
precisamos fazer antes de colocá-las em nosso jogo. Vou selecionar todos eles. A primeira coisa que vou
fazer é mudar
esse modo de filtro para Point No Filter, porque essa é a
configuração que você deseja para o Pixelate e, obviamente, você precisa
clicar em Salvar antes de eu mostrar Mas você também pode clicar em
Inscrever-se aqui. Agora você tem Point No Filter e clica em Aplicar para adicioná-lo. A razão para isso é porque esse modo de filtro realmente
desfoca levemente o sprite E se você usa pixel,
não parece muito bom. Vou te mostrar que, se eu arrastar o sprite
para o meu jogo e rolar para baixo para ver o sprite lá, você
poderá ver todos os pixels Se eu escolher o
filtro bilinear e clicar em Aplicar, dá
para ver que fica muito desfocado, não é
o que Quero escolher Apontar sem filtro para que eu tenha
todo o sprite limpo Então, a segunda coisa que vou
fazer é mudar
esses pixels por unidade porque não
quero que o sprite
seja tão pequeno Eu quero que sejam talvez dez. E, na verdade, quanto
menor esse número, maior será o sprite Acho que essa é
uma configuração muito boa para mim, por enquanto, dez pixels por unidade. E, obviamente,
vou querer mudar isso para todos
eles aqui, garantir que todos esses pixels
por unidade estejam definidos como dez. E o modo de filtro é 0,0
Filtro e clique em Aplicar. A maneira como eu realmente pude
ver esse sprite é arrastando-o
diretamente para o meu jogo E o que isso faz é criar um objeto para o meu sprite
com uma renderização de sprite Então, na verdade, é o mesmo
que clicar com o botão direito do mouse, novo objeto escolhe um triângulo É exatamente a mesma
coisa, só que
isso usa um triângulo
e, obviamente define qualquer sprite que eu tenha arrastado como o sprite
padrão Mas vou
excluí-los porque não quero realmente criar novos
objetos. Quero atribuir esses arquivos diretamente aos
renderizadores de sprites que eu já tenho, que são o quadrado e o quadrado extensível e o
triângulo e o círculo Essa é uma grande quantidade de terminologia que estou usando para você e
pode ser um pouco confuso
pensar
em tudo no contexto de desenvolvimento de jogos Mas saiba que, no momento tudo o que fizemos foi importar esses quatro arquivos
que vamos
usar para adicionar um pouco
de jogo de estilo de vida. E atualmente
temos renderizadores de sprites,
que estão renderizando tipos
de Vamos
substituí-los por
esses sprites que
criamos Portanto, certifique-se de obter
as configurações como eu faço. E então vamos começar
primeiro com o jogador. Vamos até o player e
temos uma qualidade de sprite aqui, que é para onde vamos
arrastar nosso sprite Vamos incluir um menor. Vemos instantaneamente, parece
um pouco doentio. E isso é porque
a cor ainda está definida como amarela. Vamos definir isso como
branco, eu diria. Na verdade, esse é um tamanho muito
bom para o meu player. Eu quero que seja um player
bem pequeno no meio da tela, acho que isso é realmente bom. Mas há algumas
coisas que eu preciso mudar. E foi isso que eu
quis dizer quando disse que os sprites afetam bastante o seu
jogo Obviamente, com todos os colisores
, as alturas de salto e todas as outras variáveis ou
ajustes que você precisa fazer, seu jogo é
centrado no tamanho dos sprites, ou melhor, na
aparência dos Se você estiver usando meus sprites, o
que eu recomendo, será muito
mais fácil acompanhar exatamente o que estou fazendo
do que se você usasse os seus Mas, dito isso, você pode usar o seu próprio se souber
o que está fazendo, porque você só precisa fazer ajustes
semelhantes no seu jogo De qualquer forma, dito isso,
deixe-me primeiro trocar este Box Glider para ter certeza de
que ele se encaixa no meu sprite E você pode pensar
que isso é realmente um bom tipo de
ajuste para o meu sprite, mas na verdade vou
torná-lo um pouco menor E a razão para
isso é se estamos jogando um jogo e você
tem algo como uma bala ou um projétil atingindo o topo da
tela aqui Então, digamos que algo acontece
e atinge você imediatamente. Na verdade, isso não está
atingindo o sprite, mas atingiria o Portanto, o inimigo, você prefere o jogador,
sofreria danos, o que pode ser bastante frustrante
se você estiver jogando um jogo Então, geralmente, é
uma boa ideia colocar essa renderização de sprite o mais baixa
possível aqui, para que você obviamente não
caia no chão Mas então queremos
torná-lo um pouco menor, então queremos torná-lo
algo assim. Agora, se você for atingido aqui, tecnicamente você não morrerá. Mas se você for atingido ali, em qualquer lugar dentro desse bloco, que é o jogador principal,
podemos até mesmo torná-lo um pouco
menor, como lá. Então você vai sofrer danos ou talvez até morrer e ter que
começar o jogo de novo. Mas, basicamente, isso
torna um pouco mais divertido para o jogador
jogar um jogo em que ele
não é constantemente
penalizado por ser atingido no
pixel superior direito do personagem Acompanhe isso.
Obviamente, qualquer jogador que você tenha, deve se
certificar de que ele se encaixa dentro dos
limites do box clider, mas não exatamente que
você tenha espaços em branco Eu acho que isso é muito
bom. Por enquanto. Eu mudei minha caixa Clider. Não preciso
mudar mais nada. O corpo da crista não é
afetado pelos sprites. O movimento do jogador
deve ser bom. Tem quase o mesmo tamanho e
eu mudei meus sprites. Se prosseguirmos e clicarmos em Play, você pode ver que agora eu realmente tenho um personagem secundário e posso
movê-lo e pular. Obviamente, não
tem animação, então parece um pouco idiota Mas este é, na verdade, o começo da adição de um jogo no estilo sprite E você pode ver
que isso realmente melhora consideravelmente
a aparência do nosso jogo. Quero dizer, obviamente, como eu
disse, parece idiota agora. Mas se você simplesmente pegar uma moldura congelada
e olhar para ela, mesmo que ela realmente não
se encaixe no estilo artístico, fica muito
melhor quando você tem coisas
reais no
jogo do que quadrados Na maioria das vezes, como eu
disse, quadrados podem ser legais. Eu fiz muitos jogos apenas
com formas. Mas nesse tipo de caso,
para esse tipo de jogo, parece um pouco
mais profissional ter sprites
reais. Então, não
vamos parar por aí. Na verdade, vamos
adicionar todos
os outros sprites de que precisamos
aos nossos outros objetos Há algumas mudanças que
precisaremos fazer aqui. A primeira coisa é
que, como vamos usar nuvens
como plataformas, obviamente
precisamos que
todas tenham o mesmo tamanho porque temos apenas
um sprites de nuvem Todos eles precisam ser tão grandes. Na verdade, isso não é um problema para todos os nossos blocos aqui, porque todos
são do mesmo tamanho. Mas esses três
no início têm tamanhos
diferentes. Então, vamos ter que
mudá-los um pouco. Eu vou chegar a isso. Mas
vamos começar indo até minha pasta
de sprites e arrastando essa nuvem Agora já podemos ver que isso faz com que pareça um
pouco estranho Temos uma nuvem incrivelmente
longa e plana, e vou corrigir isso
ajustando a escala de volta para um. Temos o
tamanho padrão para nossa nuvem. Também vou fazer
isso com os outros dois objetos do chão. Na verdade, não vou
escolher três porque dois são mais do que grandes
o suficiente para o meu jogo. Vou ajustar isso um
pouco à medida que avança no meu jogo,
mas, por enquanto, isso é bom como
ponto de partida para o meu jogo A última coisa que preciso fazer é obviamente, trocar os colisores. Porque essa não é a colisão. Eu quero, eu quero que seja
algo mais parecido com isso. Vamos aumentar um pouco. Ali e lá embaixo. Como eu disse, você obviamente
não quer que o colisor seja necessariamente
assim,
porque então ele não pode se apoiar em nada, mas você também não
quer que ele esteja aqui pois eles estão no
meio da nuvem Eu diria que um bom equilíbrio
estaria em algum lugar por aí. Você ainda pode ficar um
pouco atrás das nuvens, mas ainda pode se ver, talvez movê-la um pouco para
cima, obviamente para baixo. É menos importante porque
você provavelmente não vai
pulá-los de baixo. Mas isso deve ser bom. Você não quer realmente fazer esse tipo de coisa com projetos, tanto
com nuvens. Porque você
realmente não gostaria de
cair se houvesse
uma nuvem lá. Mas você pode fazer isso um pouco, talvez algo assim. Como eu disse, isso não
precisa ser perfeitamente exato, mas você terá uma ideia ao jogar
e poderá ajustá-lo Obviamente, esses são
seus aceleradores. Na verdade, vou
excluir essa falha e copiar essa
porque não tenho vontade de redimensioná-la novamente E todos eles devem ter o
mesmo tipo de colisor de tamanho. Se eu continuar e clicar em play agora,
podemos ver como fica. Entre e eu posso cair nessa nuvem e me
mover ao longo dela. E quero dizer, parece bonito. OK. O único problema é que o player está meio que continuamente
na frente da nuvem E isso na verdade não é
o que eu quero. Eu prefiro que o jogador fique
atrás da nuvem. Para fazer isso,
na verdade vou usar uma variável dentro desse script de renderização
Sprite, chamada order in layer Vou definir as nuvens
em ordem na camada seis. Vou configurar meu player para
ficar em ordem na camada cinco. Agora podemos ver que, quando
começarmos a jogar, devemos ser capazes de ver
o jogador realmente cair atrás das nuvens, um
pouco mais do que eu queria. E acho que
parece um pouco melhor em termos de design de
jogabilidade. Agora, obviamente,
acabamos de adicionar esses sprites nas duas
primeiras plataformas Não adicionamos nenhum ladrilho aqui. Ainda há o retângulo
padrão, então
precisaremos corrigir isso Vamos começar voltando aos sprites e arrastando a
nuvem de volta para dentro, ajustando a escala para E agora vai
ser um
pouco complicado, porque
teremos que
mudar isso exatamente como tentamos
fazer o tempo todo Primeiro, precisamos
trocar o planador Box
e, em seguida,
ajustar cada um
desses objetos-filhos para
que tenham ajustar cada um
desses objetos-filhos para
que tenham o
tamanho correto para o sprite Infelizmente,
isso vai dar muito trabalho, porque agora
temos que refazer todos os nossos sprites,
ou melhor, todos os blocos que já
criamos em termos
dos novos Se fôssemos examinar
cada um deles, teríamos que editar o Box Glider, adicionar coisas novas, mudar tudo É um pouco confuso e
dá muito trabalho. Na verdade, existe uma maneira
fácil de contornar isso. Pode parecer um
pouco intuitivo, mas o que vamos fazer
é, na verdade,
voltar para o espaço que temos
exatamente como tínhamos antes. Configure-o como estava normalmente antes de adicionarmos esse sprite E então vamos
criar dez novos prefabs, e vamos usá-los como pontos de
referência para criar nossos novos prefabs
com nossos Em seguida, vamos
excluí-los posteriormente. Isso pode parecer
muito mais trabalhoso, mas na verdade é
consideravelmente mais fácil a longo prazo, fazer isso dessa
maneira do que fazíamos antes A primeira coisa que
vamos fazer é trocar os prefabricados spike
e spike ball porque esse é, na verdade
, o primeiro passo Temos que lembrar que
esses pré-fabricados dentro de
nossos pré-fabricados são, na verdade, os próprios pré-fabricados. Então,
temos que mudar isso. Vamos começar mudando o pico para o sprite dos picos Veja que, na verdade,
não parece tão ruim. Temos que mudar a
escala de volta para um. É muito importante que você use a mesma escala ao
usar pixel art. Como você não pode
ter um pixel menor que o tamanho do
outro, parece muito ruim. Certifique-se de que todas as suas
balanças estejam configuradas para uma. Na verdade, preciso me lembrar fazer isso com o jogador também. Antes que eu esqueça, talvez eu
precise alterar o tamanho dos sprites por unidade de pixel, que definimos originalmente
aqui, esses pixels por unidade Mas certifique-se de definir
tudo na escala um,
caso contrário, não
ficará ótimo. Temos nossas nuvens em
uma e nosso jogador em uma. Isso é bom. Vamos voltar aos nossos modismos anteriores e
mostrar que nosso pico está em um, e precisamos que nossa bola
de espinhos também esteja em um De qualquer forma, vamos voltar
aqui. Vamos começar tornando a
cor normal, que é branca. Então, não vamos
mudar isso de forma alguma. E então eu vou realmente
remover esse colisor de polígonos, e vou adicionar
um simples colisor de E você pode pensar que
faz mais sentido
adicionar talvez três aceleradores de
polígonos,
mas confie em mim, isso é incrivelmente complicado para
o que estamos Só precisa ser um
tipo de
erro básico do colisor que muitos novos desenvolvedores do
Unity cometem: eles tentam tornar seus
colisores o mais precisos
possível, como adicionar talvez uma linha aqui, uma linha aqui, uma linha
aqui Realmente não é um bom
uso do seu tempo. E você pode fazer
algo assim e isso fará o
trabalho perfeitamente bem. Na verdade, isso torna o jogo
um pouco mais agradável jogar, porque
você não quer morrer se bater, como eu disse, na pequena ponta de
um espigão ali mesmo
e o jogador nem perceberá quando estiver
jogando Só que você pode usar o box
glides para muitas coisas.
Obviamente, vamos
usar um círculo aqui Mas, para isso, um planador de caixa
fará mais do que bem. De qualquer forma, vamos abrir a bola de espinhos e
fazer o mesmo aqui Vá até sprites e arraste o sprite
da bola de espinhos,
mude-o para branco para que
tenhamos a E então podemos
realmente aumentar um pouco
o tamanho do
slide circular Em vez de usar
esse colisor de edição, vou usar
esse raio definido 0,6. Acho que já está muito bom
porque, como eu disse, você não quer morrer
se chegar ao fim Mas essa é a maioria
do sprite, então tudo bem. Sim, nesse momento, já temos nossos pré-fabricados para
nossos sprites Alteramos o
sprite, editamos os coliders e
garantimos que ele esteja configurado para a escala 1 Agora, se voltarmos
para nossos ladrilhos, poderemos
vê-los adicioná-los a um jogo. Mas eles podem não
parecer muito bons. Por exemplo,
este está na nuvem e eles são um pouco
maiores do que eram antes. Algo assim é
mesclá-los.
Obviamente, eles estão
muito mais abaixo. Então, isso torna esse
salto um pouco mais difícil porque
eles também são mais largos. Como eu disse, todos
esses pré-fabricados estão na verdade, um pouco
arruinados agora, de certa forma Mas vamos
fazer o que eu disse antes e, na verdade,
usar um monte de novos pré-fabricados, porque
acho que isso realmente
facilitará as coisas a longo prazo De qualquer forma, provavelmente levará aproximadamente
a mesma quantidade de
tempo, porque poderíamos simplesmente alterar cada
um desses sprites, adicionar a caixa Clyde, adicionar a eles, mas então temos que mover tudo isso para cima
para ajustar o Meu Deus, temos que mudar
praticamente tudo o
que já adicionamos. E na verdade, na minha opinião, não é muito mais rápido nem mais rápido do que apenas
criar novos pré-fabricados Então, vamos prosseguir e
arrastar um novo andar para baixo. Portanto, temos um novo pré-fabricado. E vamos começar
desempacotando esse pré-fabricado. Não está mais vinculado.
Acabamos de criar uma referência, agora temos nosso novo prefab Vamos chamá-lo de piso, um A. Eu ia
copiar isso dez vezes. Temos ladrilho um A, teremos ladrilho dois A
ladrilho três
A ladrilho quatro A
,
etc., até que tenhamos todos os dez ladrilhos com uma
cópia de si mesmos feita Depois de fazer isso, você pode
começar a refazer todos os seus
pré-fabricados antigos como novos. Vou seguir
em frente porque é um processo
muito tedioso e você realmente
não precisa me
ver editando a mente Mas, basicamente, com
os novos sprites, basta criar um
monte de novos prefabs com base nos antigos que E certifique-se de que, depois de
terminar seus pré-fabricados, eles tenham todos os atributos
que os antigos Então, seu bloco, um roteiro
claro, seu slide de caixa e
todas essas coisas. Certifique-se de que
tudo isso esteja nos pré-fabricados. E uma vez que você tenha feito isso,
então você está pronto para ir. Depois de terminar de
criar todos os seus prefabs, isso deve ser
tudo o que precisávamos fazer, mas há mais algumas
mudanças que precisamos fazer Em primeiro lugar, precisamos
excluir todos os nossos blocos antigos
aqui porque não
precisamos mais deles. Temos nossos novos azulejos
com todos os nossos sprites. Temos piso de um A, até dez A.
A outra coisa que
precisamos mudar, porém é que precisamos ir até
aqui até a câmera principal. Podemos ver que todos os blocos do nosso mapa
estão faltando agora. Porque o que fizemos foi uma
matriz aqui que diz,
ok, use esse bloco do mapa, mas o bloco do mapa
não está mais lá. Diz que não sei
onde está o arquivo. Precisamos substituí-los todos esses novos blocos que
criamos
aqui porque eles são, na verdade novos objetos que criamos ou melhor, novos arquivos
que criamos. Na verdade, isso é tudo o que
precisamos fazer para criar nosso novo jogo baseado em sprites Vamos em frente e aperte o play. E podemos ver agora que temos nuvens e um pequeno
salto nas nuvens Temos nossos novos sprites surgindo exatamente como
queríamos Temos nosso sprite aqui, que tem duas nuvens, e
temos um pico O único problema, no entanto, é que você notará
que os sprites estão, na verdade,
muito próximos um do
outro e que o poço de salto
não é alto o suficiente Esses são todos os ajustes
que precisamos fazer. Tivemos que testar nosso
jogo para vê-las, mas na verdade as nuvens estão surgindo umas sobre as outras Isso não é bom. Na verdade, isso não é exatamente o que queremos. Vamos seguir em frente e realmente
corrigir isso um pouco. A primeira coisa, felizmente,
é que, na verdade,
criamos todos os nossos scripts de forma
praticamente dinâmica Temos essa
variável de deslocamento aqui, que indica a distância que as
nuvens devem estar umas das
outras antes de gerarmos
uma nova, olhamos para esta, é menos 5,55,
esta é 4,2. Tecnicamente, elas estão separadas por
menos de 15, mas quando começamos a
adicionar nosso script, não
funciona exatamente assim O que estamos tentando mudar é frequência com que eles são,
não o quanto eles aparecem Voltamos
ao script aqui que
gera nosso mapa. Na verdade, podemos
codificar esse valor aqui para oito e, na verdade,
não é uma
variável que usamos Vamos consertar isso. Vamos
voltar aqui e chamá-la de frequência de desova Vamos garantir que definamos isso
para a variável aqui. Obviamente, o offset é, na verdade a
distância em que ele aparece
na frente da câmera Desculpe, eu esqueci disso. É por isso que eles não deram certo. Mas a que
distância eles aparecem um do outro está essa nova variável que, na verdade,
codificamos e a corrigimos Agora vamos voltar para
a câmera principal e mudar isso para
algo como 12. E vamos ver se isso
parece um pouco melhor. Atualmente, o offset é 15. Vamos ver se aparecemos
no primeiro
ali e no segundo Ok. 12 é um pouco alto. Vamos configurá-lo para
algo como dez. Veja se isso funciona. Dez
parece bastante promissor. Acho que isso pode ser bom. Sim. Tudo bem. Na verdade, vou fazer 11 só porque quero
mudar mais algumas
coisas sobre isso. A segunda coisa que eu realmente
quero fazer é parar com isso. Eu quero mudar isso para 11. Em segundo lugar, não
gosto do fato as nuvens estarem surgindo logo
na parte inferior do mapa, então deixe-me alterar esse Y
mínimo para menos quatro Na verdade, vou fazer com que o máximo de Y seja
algo como dois. É um pouco mais fácil
mover as nuvens para cima e para baixo. Então, obviamente, preciso mudar
a altura de
salto dos meus jogadores para algo
mais
ou menos dez, ou talvez até 12,
para que eles possam
pular adequadamente para as novas nuvens. Vamos ver, com
todos esses ajustes, agora
temos uma sensação de jogo um pouco
diferente O jogador pode
pular muito mais alto. Talvez 12 seja um pouco alto, mas eu posso corrigir isso, obviamente. Vamos fazer talvez dez e
voltar e ver como fica. Agora, com a altura de salto de dez, eu diria que parece muito melhor. A escala de gravidade pode
ser um pouco menor. Cegonhas flutuando
no chão, mas na verdade parece uma
figura bastante decente para o meu jogo Eu posso dar esse salto, mas talvez eu tenha que mudar isso
um pouco também. Talvez eu aumente um pouco a
altura do salto, mas também a
escala gravitacional. Mas parece que tudo isso é
realmente possível com essa nova variável que eu decidi que é
realmente muito boa. E podemos ver agora que criamos um jogo um pouco mais
bonito. Tudo está um pouco mais limpo e tudo
parece muito melhor. A única coisa que vou
mudar antes de terminar este vídeo, sei que foi
muito longo, é que vou tornar
todos os sprites um pouco menores Eu vou fazer um, torná-los um jogo um
pouco menor. Digamos, talvez, para 12. Sim, eu diria que 12 é
muito bom, como eu disse. Porque agora eu decidi fazer meus sprites um pouco menores Obviamente, terei ajustar todos os meus aceleradores e
talvez a frequência de desova
da nuvem para que eles
ainda estejam à mesma distância Mas, devido à forma como
codificamos nossos scripts, isso é realmente
muito fácil de fazer E eu recomendo que você continue adaptando seu jogo
à medida que o desenvolve É um aspecto muito normal do desenvolvimento de jogos mudar
seu jogo à medida que você o cria. E pode parecer
irritante estar constantemente fazendo alterações em seu jogo e tendo que consertar as coisas Mas confie em mim, é
muito melhor
do que a alternativa
de ter um jogo, com o
qual você não está
particularmente feliz porque não
queria mudar nada. Portanto, certifique-se de adaptar
constantemente seu jogo para que ele reflita
exatamente o que você deseja Quero que meu jogo tenha sprites um
pouco menores. Vou ter que
ajustar todos os meus ladrilhos, meus pré-fabricados e os
colisores do Talvez em praticamente todos os meus sprites, na verdade,
no meu player também E então talvez eu tenha que ajustar o script de geração de mapas com que
frequência eles praticam esportes, porque eu quero que eles tenham o mesmo tipo de distância Então, vou
ter que tornar isso um valor um pouco menor também. Mas depois de fazer tudo
isso, não demorará muito
e terei um jogo, qual provavelmente ficarei com o
qual provavelmente ficarei
muito mais feliz
porque reflete o que tenho
em mente. Legal. E então a última
coisa é apenas testar. Talvez precisemos
alterar essas variáveis mais
uma vez antes de
terminarmos o vídeo, mas deixe-me ver. Porque eu meio que queria pular de nuvem em nuvem Oh, eu esqueci de
ajustar o planador
de caixa do player. Vamos
fazer isso rapidamente. E
acho que a nuvem em si deveria estar bem,
mas deixe-me
ter certeza de que deve ser
boa para o jogador. Vamos ver as nuvens. Basta ajustá-los também. Deve estar bem. Vou
copiar esse componente, então tenho que fazer a
mesma coisa
aqui e colar seus valores. É como se copiar e colar
devesse ser bom. Vou fazer a
mesma coisa com todos
os pré-fabricados só para ter certeza de que não
preciso refazê-los Deixe-me continuar e colar os valores dos
componentes
para todos eles. Agora eu sei que parece que
fizemos um monte de coisas
e depois mudamos, e depois fizemos de novo
e mudamos. Na verdade, não é uma
coisa ruim. Isso significa que você está seguindo um jogo específico
que tem em mente. E o fato de
você estar ajustando as coisas e mudando
isso significa que é um pouco mais parecido com um organismo
real do que com essa coisa estática E é isso que um jogo deve ser enquanto você o
desenvolve. Mas de qualquer forma, vamos ver se isso é realmente adequado
ao que eu quero. Eu tenho saltos altos, vou de nuvem em nuvem Na verdade, parece
muito melhor, na minha opinião. Eu acho que isso é realmente muito bom. Isso é realmente ótimo. Temos praticamente
tudo o que eu tento para salvar a cena no modo play, o que você não tem permissão para fazer. Temos
praticamente tudo o que eu realmente queria neste
momento do jogo. Você tem nuvens
para as quais pode pular, você tem obstáculos nelas. Na verdade, isso é muito legal. Obviamente, não parece
ótimo porque o jogador não
é animado e não tem bolas com espinhos Agora os espinhos estão
se movendo ou algo assim. Vamos começar a
animação no próximo vídeo. Mas espero que, se
você acompanhou, tenha um jogo um pouco
mais bonito Apesar de termos acabado de
adicionar sprites e não ter mudado
muita coisa, você pode ver, obviamente tivemos que
ajustar muitas partes
do nosso jogo porque
adicionamos os sprites, você pode adicionar sprites
desde Mas acho que muitos
desenvolvedores preferem
criá-lo primeiro com
modelos e depois ajustar
as coisas à medida que avançam ,
pois isso facilita. Você não precisa fazer toda
a arte antes de começar. Mas isso é, na verdade
, tudo o que queremos fazer hoje. E acho que é seguro
dizer que nosso jogo parece muito melhor agora do que
no início do vídeo. Veremos
no próximo vídeo, depois de adicionarmos a animação, como o jogo
realmente começa a ganhar vida. E vamos fazer mais
alguns ajustes
com o jogador para
fazê-lo ficar de frente para o outro lado quando estiver virando
à esquerda e à direita O que melhorará muito
a aparência do jogo. Mas, por enquanto, acho que parece muito melhor do que
quando começamos. E espero que você tenha conseguido
acompanhar e adicionar esses
ou seus próprios
sprites ao jogo. Obrigada.
8. 7. Animando nossos personagens: Aqui e bem-vindo de volta à Unity. No último episódio, adicionamos todos os nossos sprites
aos nossos jogos Temos um menor
para nosso jogador. Temos um monte de
nuvens para as plataformas. E temos
bolas pontiagudas e pontas nas nuvens para as coisas que temos para evitar os obstáculos Obviamente, tivemos que
passar muito tempo no último episódio ajustando as coisas e
movendo-as para que ficassem todas
na posição correta Eu também tive que fazer isso um
pouco mais tarde apenas para ter certeza de que todos estavam exatamente
onde deveriam estar Mas isso vai
ser subjetivo para você. Obviamente, você sabe qual é
a posição certa para o seu jogo e também para
o seu projeto. Mesmo que você esteja me
acompanhando, não
vai se parecer
exatamente com o meu. Você os terá exatamente
na mesma posição. Então, desde que tudo
pareça bom e esteja na
posição certa para o seu jogo
, é ótimo que possamos
passar para a animação. Porque se jogarmos
o jogo agora, podemos ver que, embora todos os sprites e
tudo pareçam bem, agora está
tudo bem
como uma moldura congelada Mas no minuto em que
começamos a nos movimentar, o fato de o jogador não estar
se movendo, meio deslizando,
ele
fica praticamente sem vida Na verdade, isso faz com que
o jogo pareça um pouco
barato ou apressado, e obviamente não queremos que nosso jogo pareça
barato ou apressado, mas queremos que pareça um
pouco mais com um jogo
real que você veria no Steam, no fliperama ou
em qualquer Então, para fazer isso,
vamos realmente
ter que adicionar
animação ao nosso jogo. E a forma como
vamos animar, vou mostrar a vocês, é um processo decentemente
complicado se você se aprofundar Porque, obviamente,
existem trabalhos completos baseados em animação para jogos nesses jogos massivos que você vê como o
Treble Studios É muito diferente
do que vamos fazer hoje, mas no Unity,
apesar de ser um processo bastante complicado, ele realmente fornece
uma maneira bem fácil de fazer isso. E eu vou
orientá-lo sobre isso e você descobrirá que
provavelmente o entenderá rapidamente. Antes que eu me
precipite demais, vamos apresentar o que
vamos fazer. Por enquanto, vamos animar
apenas o jogador. Obviamente, à medida que
avançamos no jogo, pode
haver outras
coisas que precisamos animar. E podemos animar
coisas novas à medida que as adicionamos. Mas, por enquanto, vamos
começar a animar o player, porque essa é
a parte mais importante Para começar, vamos
entrar em ativos e criar uma nova pasta
chamada Animation. É aqui que
vamos armazenar todos os nossos arquivos de animação. Agora, assim como os sprites são
arquivos, nosso código é arquivos. Até mesmo nossas cenas e nossos prefabs também são,
na verdade, arquivos As animações que
criamos também serão arquivos. E isso é importante para
algumas terminologias aqui. Uma animação ou
um clipe de animação é como um vídeo em loop
de uma coisa específica Como uma animação em execução.
Ou uma animação de salto Isso vai ser
um vídeo em loop,
você pode chamá-lo, mas é uma mudança em
loop de Então, vai se
mover de uma certa maneira. Isso será o nome
de uma das animações. Então, a forma como
vamos animar no Unity é armazenar esses arquivos de animação
porque eles são salvos como arquivos
dentro dessa pasta Em seguida, vamos criar
um novo objeto chamado controlador que
dirá ao Unity qual deles
usar em qual ponto, e é aí que
colocamos nossa lógica. Mas antes que eu me
precipite demais, vamos começar com
as animações reais Agora, em termos
dos sprites reais que
vamos usar, obviamente
fiz
mais alguns sprites para as animações Vamos fazer o que é chamado de animação baseada em sprites, em que você tem
vários sprites diferentes Como se você tivesse um
sprite correndo em que talvez essa perna seja levantada
e depois uma para baixo, depois uma para o lado
e outra para baixo novamente E eu obviamente já fiz
esses sprites. É claro que eles serão
vinculados por este vídeo. Basicamente, tudo o que nossa animação
fará é dizer ao Unity qual desses
sprites mudar em que momento.
Na verdade, é muito fácil. Há outro tipo
de animação em que você basicamente pega todo o objeto que criou aqui
e cria todas essas pequenas partes
do corpo como subobjeto Um braço seria um objeto, a única perna seria um objeto. Basicamente, diga ao Unity, ok, gire isso neste momento e
mova-o de volta neste momento E isso é um
pouco
mais complicado do que o que vamos
fazer hoje. Obviamente, é uma maneira
muito melhor de
animar coisas mais
complicadas Como se você não estivesse criando um jogo Pixelart, por exemplo É basicamente
assim que você vai ter que animar, na verdade Porque você não pode criar
um sprite diferente para cada quadro
que você deseja Mas para Pilar, assim como
costumavam fazer antigamente,
vamos usar animação baseada em sprites E, na verdade, parece muito melhor para o piloto, na minha opinião. Você nunca pode realmente obtê-lo
exatamente como deseja
sem usá-lo para o Pix L. É isso que
vamos fazer Agora, obviamente, depois baixar todos
esses arquivos de sprites, vou portar os mesmos. Esses
serão os sprites de que precisamos para nossa animação em execução E eles são sprites
menos dois a seis. Agora, na verdade, acabei de
colocá-los no lugar errado. Deixe-me cortá-los e
colocá-los em sprites. Por serem sprites,
existem animações. Mas, obviamente, quando você
o importa diretamente para a pasta sprite e precisamos
fazer as duas alterações que
fizemos da última vez, defina isso como 12 e
defina como ponto. Sem filtro. Agora podemos ver que eles são exatamente iguais
aos
meus outros sprites Se eu for aqui para Minor,
podemos ver que não há absolutamente nenhuma diferença entre
esses dois, exceto o nome. Se eu for até o meu player, posso realmente arrastá-los
como sprites Eu vou dizer, ok, eu quero que o
jogador seja um sprite correndo. E podemos ver agora
que ele está preso lá. Mas nem sempre
queremos que nosso jogador esteja sempre nesse sprite em
execução Queremos que ele mude de
um sprite para outro. E para fazer isso,
precisaremos de um novo componente chamado animador, como já pesquisamos, mas precisamos adicionar
esse animador Esse animador basicamente
permite que a Unity diga, ok, isso é algo que tem
um controlador de animação, ou isso é algo
que tem animações Vai ser uma
troca entre. Eu explico toda a
terminologia à medida que chegamos a ela, mas esse componente
aqui é basicamente apenas uma referência ao fato de
que estamos animando A referência ao
fato de ter um controlador. Agora, para adicionar um controlador, que é a principal
coisa que precisamos aqui,
vamos usar a animação da janela
e, em seguida, a animação novamente. E isso abrirá
a segunda janela aqui. Animação de janela. Animação.
Ou você pode clicar no controle seis e abrir essa janela de animação
e ela dirá,
para iniciar o player animado, crie um clipe de animação que seja como
correr ou pular Esse é o clipe real do qual
estávamos falando. Isso acompanha o
objeto que selecionamos atualmente. Se selecionarmos a
câmera principal, ela diz. Cria um animador
e um clipe de animação. Obviamente, só dizia
criar um clipe de animação porque já temos
um animador para player Mas acho que se você
clicar em criar aqui, ele simplesmente
criará esse
objeto animador para você automaticamente É muito bom criar a si mesmo para que
você possa estar ciente de que isso
faz parte do processo. De qualquer forma, para criar
um clipe de animação, basta clicar no
local aqui. Queremos entrar na animação de
ativos, porque é aí que
vou armazenar meus clipes e vou
chamá-la de player run Agora eu criei o que
é chamado de clipe, e podemos ver que muito disso já
foi realmente preenchido. Agora temos o que é
chamado de controlador. Se fecharmos isso
e voltarmos para nossa animação,
teremos dois arquivos. Temos esse player rodando,
que é meu novo clipe. Mas eu também tenho esse novo objeto
aqui, que é chamado de controlador de animador. Esse é o coração
do animador. Isso será o
que lhe dirá qual animação
fazer, em que ponto. Se clicarmos duas vezes
sobre isso, podemos realmente ver essa nova
janela se abrir aqui. E este é meu controlador, esse é meu animador de jogadores Esse aqui é
meu clipe de animação. Para dar um breve resumo,
retroceda um pouco, esse é um componente
que acabamos de adicionar. Isso basicamente diz, ok, esse objeto é algo
que tem um controlador. Este controlador é o que
eu estou vendo aqui. Isso quer dizer, ok, em
qual animação eu quero estar,
em que ponto? E essa animação é
esse clipe aqui, que são as coisas específicas. Vou ter um de corrida, vou ter um de salto, vou ter um ocioso E então meu controlador
vai dizer, ok, esteja neste quando
eu estiver fazendo isso, esteja neste quando eu estiver
fazendo isso, esteja neste. Quando estou fazendo isso, você pode
pensar na corrida do jogador. Ou as animações,
como vídeos em loop,
corrida, salto,
queda, etc Você pode pensar
nesse player como o
que diz à Unity:
ok, qual vídeo
reproduzir, a que horas? E então esse controlador de
animador basicamente diz
ao objeto,
ok, eu tenho esse
controlador de player conectado Use esse tipo de coisa. Então, isso
é muito menos importante. Mas é baseado
apenas em dizer, ok, isso é algo
que tem um controlador e você precisa usar
o controlador. Obviamente, é importante. Se
eu desativasse, não funcionaria. Mas esse controlador é na verdade
um arquivo dentro do meu jogo. Então, eu preciso criar um link para esse controlador e
esse objeto específico, que é o que a Unity
fez por mim aqui. Mas de qualquer forma, não
se
preocupe muito com o que cada
uma dessas coisas significa, basta acompanhar o que estou fazendo.
Obviamente, acabamos de criar
um animador e, em seguida, temos a
animação de janela E criamos um novo arquivo para o meu player chamado player run. E isso criou um controlador
para nós automaticamente. Então, vamos começar a animar as corridas dos jogadores. Vamos
ampliar meu player. E vou clicar
neste botão Gravar, que basicamente diz que estou gravando coisas no
momento. Minha animação. Na primeira
parte da minha animação, eu quero estar nesse
sprite aqui Eu vou escolher
menos dois aqui. Este é o
primeiro sprite que eu quero. A razão pela qual eu tenho esse
botão de gravação pressionado é que ele basicamente diz que todas as alterações que
eles estão fazendo editor agora são, na verdade,
parte da animação. Se eu movê-lo para
cá, ele
mudará minha posição como
parte da animação. Mas, na verdade, eu não quero isso. Eu só quero que seja o sprite. Vou mudar meu
sprite para menos dois, mova um quarto de segundo Obviamente, 60 é um segundo
nesta visão aqui. E se eu clicar em Jogar, ainda não
consigo ver nada porque não fiz nada.
Mas eu vou te mostrar mais tarde. Vou mudar
para menos três. Eu quero que na verdade seja
aos 15. Então, aos 30 anos, quero
escolher menos quatro. Então, aos 45 anos, quero
escolher menos cinco. Eu tenho os quatro sprites que você vai compor
minha animação em execução Você pode ver
a união lá. Na verdade, quero acrescentar mais
uma coisa aqui. Realmente não
importa o que eu adiciono, mas enquanto eu
tiver algo aqui, vou
voltar para menos dois Desde que eu tenha
algo lá, a unidade sabe que essa animação tem
exatamente 1 segundo de duração. Na verdade, esse quadro
dura apenas um quadro e depois
volta para lá. Eu não tenho isso
aqui, mesmo que tecnicamente
não faça parte
da animação em execução O Unity vai
pular isso, ou melhor ,
executá-lo em um quadro e depois
voltar direto para aquele Eu não quero isso, deixe-me ter certeza de que
tenho algo aqui. Se eu clicar em play, podemos realmente
ver esse tipo de
união e parece que está tudo bem.
Parece muito legal. Na minha opinião, eu não sou
o melhor animador, mas essa será a nossa animação de corrida
para o nosso jogo Sempre podemos ajustar
a velocidade e coisas desse tipo dentro
desse controlador real Se estivermos aqui,
clique na animação, podemos alterar a
velocidade de reprodução quando estamos no jogo, mas por enquanto é como
uma animação básica Eu diria que parece muito
bom para correr. Vamos criar mais
duas animações. Ídolo do jogador. Na verdade, isso vai ser
uma coisa incrivelmente simples. Vamos apenas
garantir que a Unity
saiba que queremos
estar nesse sprite, então não é realmente uma animação, é como uma configuração de sprite Mas vamos
usá-lo para contar à Unity. Ok, verifique se você está
nesse sprite. Portanto, nossa animação é
apenas um único sprite. Vamos fazer
exatamente a mesma coisa para pular, jogar um salto e vamos
escolher sprite menos seis, que é nossa animação de salto Veja aqui agora
que está pulando. Se
quisermos ser assim, se estivermos correndo,
faremos isso. Então, agora temos todas as nossas
animações concluídas e corrigidas. Agora, o que resta a fazer
é criar
a lógica para dizer qual
fazer em que ponto. E a última coisa que precisamos fazer é adicionar um pouco de código, o que será crucial para definir essa lógica. Para criar essa
lógica, vamos ver esses parâmetros aqui. E essas são
as mesmas condições que queremos estabelecer. Então, queremos ter uma condição para saber se estamos
correndo ou não, obviamente, porque
precisamos saber se devemos reproduzir as animações
em execução Digamos que está funcionando. Vamos criar outro
bilhão que
chamaremos de
aterrado porque queremos saber se estamos
pulando ou não, ou melhor se estamos no
chão por Se realmente olharmos para
eles, são dois bilhões. Eles podem
ser verdadeiros ou falsos. O que vou fazer
agora é criar uma lógica que
basicamente define essas três animações
como sendo reproduzidas em determinados momentos, com base em quais delas são verdadeiras
e quais são falsas Então, para fazer isso, eu
vou até aqui para qualquer estado. Na verdade, isso é muito, muito útil em termos de animador E está basicamente dizendo, ok, não importa qual
animação esteja sendo reproduzida, porque esses são
os chamados nós de estado. E eles dizem, ok,
enquanto eu estiver na animação de execução do
jogador, estou nesse estado de execução do jogador
e posso estar no estado inativo
do jogador Eu posso estar no estado de salto do jogador. Estamos criando uma máquina estatal muito
básica. Mas esse nó de qualquer estado
basicamente nos permite dizer, ok, não importa
em que estado eu esteja, vá de lá para este. E a maneira como vamos partir daí
até aqui,
ou melhor, entre essas
diferentes animações, é usando transições Se eu continuar lendo aqui, posso fazer a transição, ok? Transição disso para aquilo. E dentro dessa transição
é onde eu defino minha lógica. Digamos que eu queira, desde que eu não esteja correndo, se
correr é falso. Eu quero ficar ocioso. Enquanto eu não estiver no chão, quero passar do inativo para E enquanto eu estiver pés no chão, quero
ir do salto para a corrida Isso pode parecer
bom, pois temos um
tipo básico de estrutura rudimentar Mas, na verdade, isso é muito falho, porque
não temos como, antes de tudo, passar
da corrida ao salto Enquanto estivermos correndo
e pulando, só
podemos ficar inativos Se estivermos correndo e não
pararmos de correr e
pularmos, não vamos nos
mover, vamos ficar na minha animação de corrida. Além disso, se eu estiver pulando
e na verdade ainda estou, quando aterrissar, ainda
vou voltar a correr
e depois vou fazer a transição
para a marcha lenta porque tenho
essa coisa aqui Mas é uma máquina muito
defeituosa porque eu nem tenho
estados que definam Se eu quiser fazer isso
realmente completo, eu teria que fazer uma
transição lá, uma transição para lá, bem
como uma
transição para lá. E então seria
um pouco mais completo. Mas tudo isso é uma maneira bastante
complicada de fazer isso. E eu não vou
usar isso. Eu quero deletá-los. Em vez disso, vou usar
esse modo de qualquer estado, o que tornará
esse processo muito mais fácil. Em primeiro lugar, vou
de qualquer estado, vou dizer que
faça a transição
como da última vez, clique com o botão
direito do mouse e clique. Faça a transição para ficar inativo. E eu digo,
enquanto eu não estiver correndo, enquanto eu estiver no chão, eu quero ficar ociosa porque
isso significa que eu estou
parada no chão aqui Quero dizer que,
enquanto eu estiver no chão, em outras palavras, se eu não estiver
no ar e estiver correndo, quero
correr até aqui Eu quero dizer que sempre eu não estiver de castigo, eu
quero pular Porque minha animação de salto é na verdade, mais parecida com uma animação de
queda. Você pode ver aqui
se entrarmos no jogo e clicarmos na animação, você seleciona o jogador,
olhamos nossa animação de salto, jogamos, na verdade é
como uma animação caindo Obviamente, funciona para
pular ou cair, mas ficará
muito bom quando o usarmos,
porque tocará
sempre que
pularmos ou mesmo se simplesmente
cairmos de alguma coisa, que é exatamente o que queremos Agora, na verdade, isso é
praticamente tudo o que precisamos
fazer para nossa máquina lógica. Mas há mais alguns
ajustes. Primeiro de tudo, vamos definir isso como padrão, clicando com o botão
direito do mouse para definir como estado padrão da
camada. Na verdade, não faz muita diferença,
mas parece
que a animação ociosa deve ser padrão
em vez da em execução Ele foi configurado automaticamente para
ser executado porque é o
primeiro que criamos. Mas isso realmente não faz
diferença , está
tudo bem. A segunda coisa que queremos
fazer é definir essa
queda de duração da transição para zero. Porque eu acho
que com Pixi Lad parece muito
melhor se for zero Às vezes, você pode ajustar um pouco
porque talvez queira ser 0,1 0,2. Eu
prefiro definir como zero, mas na verdade também posso
mudar isso Vou ver, por enquanto,
vou definir como zero e garantir que todas as minhas
condições estejam corretas. Enquanto eu não estiver correndo e estiver castigo, quero
ficar ocioso Enquanto eu estiver
no chão e correndo, vou correr Sim. E sempre que não estou de
castigo, quero pular Perfeito. Então, na verdade, isso é praticamente tudo o que
precisamos fazer. Se eu clicar em jogar agora você verá que tenho meu jogador e ele permanecerá
na animação de salto porque eu não estava de castigo E ele, na verdade,
se olharmos aqui, atualmente
temos um
jogador e ele está pulando Mas, com base no que
eu escolho,
digamos que eu estabeleça a verdade Agora, na verdade,
vou ficar ocioso. Você pode ver que eu vou ficar lá. Se eu definir running true, eu
deveria estar no meu estado de execução, o que eu acredito que estou. Parece que tudo está funcionando. Tudo deve estar
funcionando bem por aqui. Na verdade, parece que nossas transições são
muito boas Mas, obviamente, não
queremos clicar aqui com base no que queremos quando estamos realmente jogando o jogo. Queremos ser capazes de dizer, ok, quando estou fazendo essa coisa
específica, configurá-las, fazer uma coisa quando estou correndo,
configurar isso para execução, em vez de fazer com que eu
venha e clique lá. E vamos
usar código para fazer isso. Vamos ver aqui
meus scripts de código. E eu vou
abrir a jogada do jogador. Vamos usar exatamente
o mesmo script que costumávamos indicar quando estou me mudando para mostrar basicamente se vou
jogar determinadas E eu vou primeiro criar uma referência para esse animador, chamá-lo de Anum Embora eu esteja me referindo
ao animador, estou me referindo ao controlador do
animador Diz interface para controlar o sistema de animação Mec Anum Mas sim, estou basicamente me
referindo ao controlador. Vou me referir a esses parâmetros que
acabamos de definir. Vou voltar aqui, voltar
ao meu roteiro e vou dizer que,
por trás dessas colisões, é quando basicamente
mudamos,
essa é basicamente
mudamos,
essa é Você pode ver que, na
verdade, eu já tenho uma variável aqui que
me diz se eles estão
no chão Na verdade, preciso ter
certeza de que está basicamente alinhado com o parâmetro do meu
animador Então você acessa o parâmetro
animators, vamos anambool, abre parênteses e você
diz o nome do bool, My b is grounded vamos anambool,
abre parênteses e você
diz o nome do bool, My b is grounded. Em seguida, vou configurá-lo
para minha variável aterrada. Na verdade, eu só vou
fazer isso aqui, e aqui, eu poderia fazer
isso a cada quadro se eu quisesse. A razão pela qual eu só estou fazendo isso aqui é porque
esses são, na verdade os únicos dois pontos
em todo o meu script em que eu mudei a variável
fundamental. E não há nenhum outro lugar onde
isso possa mudar. Então, essa é a única
vez que preciso atualizar meu animador e dizer, ok, se eu colidi
com algo, é verdade E então certifique-se de que meu
animador o defina como verdadeiro. Se eu deixar algo, é falso. E certifique-se de que meu animador saiba que eu tenho que definir como falso E isso é, na verdade,
apenas a base para o que precisamos para nosso sistema
aterrado Se fôssemos jogar
o jogo agora, ele deveria funcionar
muito bem. Sempre que aterrissarmos, teremos um aterramento, definido como verdadeiro e, em
seguida,
reproduzirá a animação certa,
seja ela inativa ou Mas ainda não
temos como controlar minha animação
em execução. Então, vamos adicionar uma
linha de código aqui. E essa seção,
para ser muito simples, vamos apenas anim. Defina bool, como da última vez. Queremos definir o
bulow está em execução , onde determinaremos se
estamos executando ou não usando esse x float Agora, lembre-se de que esse x float é alterado com base nas teclas que
eles estão pressionando. Enquanto eles
pressionarem a ou D,
ou as setas para trás ou para frente, basicamente dirá,
ok, defina x
como um número
que nos permita dizer, desde que x seja um
número que estamos executando Mas, desde que x não seja um
número, não estamos correndo. E não precisamos nos
preocupar se estamos correndo no ar ou não. Porque, se lembrarmos, nosso controlador de
animação
não leva em consideração se estamos correndo ou não no ar. Tudo o que precisamos para correr é o fato de estarmos
aterrados e correndo E enquanto não
estivermos com os pés no chão, mesmo se estivermos correndo, ela ainda
reproduzirá a animação certa Devemos nos
preocupar em definir essa variável em
execução com base no
fato de estarmos nos movendo ou não. Nós vamos fazer isso.
Vamos digitar está em execução, configurá-lo para x não é
igual a zero. Isso vai dizer que quando
x é igual a zero, isso vai ser
falso porque isso diz que x não é igual a zero. Desde que x não seja zero,
isso será verdade. Vai dizer, ok, prepare-se
para esta declaração. Na verdade, essa afirmação está retornando um booleano verdadeiro ou falso Quando x é zero,
ele retorna falso. E quando x não é
zero, ele retorna verdadeiro. Estamos dizendo que está bem,
desde que x não seja zero. Em outras palavras, enquanto estamos nos movendo, o set está se tornando verdadeiro. Quando x é zero, set
está sendo executado como false. Na verdade, esse será todo o código de que precisamos para
configurar perfeitamente nosso animador Se voltarmos para o Unity,
entrarmos em nossa cena, certifique-se de que
temos uma referência ao animador que
acabamos de criar aqui,
arraste-o para dentro, sem mais nem menos
. Nós clicamos em play. Na verdade, devemos ver
todas as animações ganharem vida perfeitamente Podemos ver que caímos, pousamos e temos nossa animação
em execução. Oh,
parece que não está funcionando. Parece que é
apenas o primeiro quadro, o que é
bastante interessante. Então, temos algo que
precisamos resolver,
mas, por enquanto,
parece que todo o resto está funcionando bem. Devemos descobrir por que
nossa animação em execução está reproduzindo apenas o primeiro quadro? E é isso que aqui
pode fazer a transição para si mesmo. Na verdade, é algo
que esqueci de mencionar, isso pode fazer a transição
apenas de um estado próprio Você precisa realmente se lembrar de não
usar, se estiver usando isso, qualquer controlador de estado.
Eu esqueci disso Mas o que vai acontecer é que,
com essas duas animações, não
percebemos isso
porque essas animações não são
realmente Eles são
apenas um tipo único de moldura que estávamos continuamente
transferindo para eles. Mas não notamos a diferença porque
eles são apenas um quadro. Mas pudemos ver que,
com o player run, estávamos apenas fazendo a transição para o início da animação Se desmarcarmos
isso, isso não nos
permitirá
basicamente atualizá-lo continuamente Estamos dizendo que vá para ela apenas uma vez e não
continue indo até ela. Você pode ficar nela
enquanto não estiver
se mudando para a outra. Enquanto desmarcarmos
isso, ele realmente consertará
tudo e
fará com que não
continue atualizando continuamente sua transição para Só faz a transição uma vez. E então, quando tenta fazer a transição para outros
lugares, acontece Mas não precisa continuar
caminhando em direção a si mesma,
o que é bom. E se, no minuto em que
fizermos
essa correção, isso deve ser
tudo o que precisamos
fazer para ter um sistema de
animação funcional. Agora podemos ver que corremos
normalmente, exatamente como queríamos. Obviamente, ainda não
nos recuperamos, que é a última
coisa que vou acrescentar antes de encerrarmos este vídeo. Mas corremos e pulamos,
exatamente como queríamos. primeiro que vou fazer é tornar
isso um pouco mais rápido, porque acho que
um é um pouco lento. E espero que isso
seja tudo o que precisamos para tornar nosso jogo um
pouco mais realista Sim, podemos ver isso agora.
Parece muito bom agora , na verdade, temos
tudo funcionando e temos um salto. E,
na verdade, tudo está muito melhor do que estava antes. Mas há uma coisa que
precisamos mudar o fato de
o jogador estar sempre
voltado para frente. E isso é, na verdade,
uma mudança muito fácil. Tudo o que vamos fazer é
ir até aqui, até essa declaração de
atualização fixa. E vamos dizer que se RB, velocidade x é menor que zero Em outras palavras, se
estivermos retrocedendo, faça com que os jogadores
transformem sua rotação Vamos escrever
Quaternion Euler. Apenas uma maneira elegante
de dizer ângulos. Não se preocupe muito com isso. Vamos
configurá-lo para nosso x zero, nosso Y para 180 e nosso X00 Se entrarmos em nosso jogo,
podemos realmente ver o
que isso vai fazer. Abra meu jogo de plataforma
aqui, vá para o jogador. Podemos ver que
os colocamos em zero. Se eu definir um y para 180, meu player
vai virar de cabeça para baixo, que é exatamente o que eu quero E então, desde que eu tenha
definido como zero, não é. E isso vai
atualizar todas as nossas animações desse
jeito para nós Porque na verdade estamos
girando o objeto em si, o que é bastante útil Vamos apenas
adicionar mais uma linha de código aqui que diz outra coisa se R vlocity x for
maior que zero, em outras palavras, se
estamos avançando, então queremos ter
uma rotação normal Obviamente, como
eu disse, isso
cuidará de toda a animação para nós,
na verdade, tudo deve ser
feito automaticamente. Se eu clicar em jogar, podemos ver que agora esse novo código nos
permitirá virar para trás, que na verdade
ficará muito melhor em nosso jogo Espero que agora você possa ver
tudo ganhando vida, e nosso jogo parece muito
melhor do que E temos todas as minhas animações
e tudo funcionando perfeitamente.
Isso é muito legal. Espero que você tenha conseguido
acompanhar e tenha um jogo bem
parecido e pareça muito melhor
do que era originalmente E você
meio que tem uma ideia de como vamos fazer
o resto do jogo. Mas, por enquanto, se você tem tudo funcionando exatamente como eu, isso é incrível. E espero que
você tenha conseguido
acompanhar o que
estamos fazendo e tenha conseguido
animar seu próprio jogador da
mesma forma que eu fiz No próximo vídeo,
vamos adicionar inimigos e um monte
de novos inimigos interessantes. E vamos fazer
um monte de mais pneus com esses inimigos só para tornar nosso
jogo um pouco mais variado. E, a partir de então,
começaremos com todas as últimas
coisas que você precisa fazer, que obviamente são a detecção de
acertos, áudio e som,
tudo mais depois disso. Além de alguns retoques
finais para melhorar a aparência E também um loop de jogo, é claro. Mas, no momento, temos
os blocos
de construção do nosso jogo meio que concluídos. E adicionamos sprites para que
pareça muito melhor. Então, isso é tudo
para este vídeo. E no próximo
vídeo, como eu disse, vamos adicionar
mais alguns inimigos interessantes. Mas, por enquanto, se
você tem tudo funcionando como eu, isso é ótimo. E vamos
começar com novo desenvolvimento no próximo vídeo. Obrigada.
9. 8. Adicionando inimigos mais interessantes: Olá, e bem-vindo de
volta à Unity. Agora, neste episódio, adicionaremos
mais alguns inimigos interessantes ao nosso jogo. Porque agora
temos apenas espinhos e bolas pontiagudas. Embora sejam um pouco variados em todos os pneus que temos, eles não são os tipos de inimigos mais
interessantes e, na verdade, são
apenas obstáculos. Vamos adicionar
dois novos tipos de inimigos
e, obviamente, eu já construí
espigões para eles Um deles
será um inimigo patrulheiro e o outro será como um inimigo cronometrado De vez em
quando é perigoso, mas depois desliga e
não é perigoso. E, para começar,
primeiro
importaremos todas as necessidades da bola de
sprites Vou clicar com o
botão direito do mouse em Importar novo ácido. E esses são, na verdade, todos
os novos sprites que
precisamos para nosso inimigo Então, temos quatro sprites robóticos, dois sprites para esse inimigo
chocante e um sprite extra
para A razão pela qual compramos esse sprite extra
é porque na verdade, vamos
animar um pouco nossa
bola de espinhos E, na verdade, é com isso que
vou começar primeiro, e para garantir que
tudo isso esteja configurado com
as configurações corretas, obviamente. E, na verdade, faça isso apenas
selecionando cada sprite Isso vai sobrescrevê-los, mas tudo bem, desde
que sejam todos iguais Filtre 12 pontos e clique Aplicar e tudo o que sabemos
agora é o mesmo. E também é assim que você
pode realmente verificar se todos os seus
sprites são iguais Contanto que estejam
preenchidos, você está bem. Vamos entrar em pré-fabricados. Vamos criar
alguns novos prefabs. Vou abrir este
e, na verdade, vou copiá-los
para
manter as etiquetas iguais. Este vai
ser nosso robô, e este vai
ser como uma bateria. Antes de fazer isso, vou
primeiro consertar minha bola de espinhos animando e vou usar animação de janela,
animação Todas essas coisas extras que
fizemos em termos de fases e estados e todas
essas coisas, isso é animação. E é bem simples, mas podemos ter uma animação ainda
mais simples se tivermos apenas uma animação Se quisermos um tipo contínuo de animação que seja
reproduzido o tempo todo, que é o que eu quero
com uma bola de espinhos, tudo o que preciso fazer é criar,
acessar meus ativos,
fazer animação e
chamá-la de bola de espinhos Então, a cada meio
segundo, vou
querer mudar para o
segundo sprite de spike ball, que é o que eu
tenho lá Copie isso e vá até lá. Você pode ver isso em ação aqui. Essa será nossa animação de
spikeball. Isso só faz com que o jogo pareça
um pouco mais interessante. Na verdade, isso é tudo o que
precisamos fazer, porque se
abrirmos nossa animação,
podemos entrar na animação. Podemos abrir nossa bola de espinhos. Veja, eu tenho um estado. Claro. Mas eu não
preciso de nenhum parâmetro trânsito
ou qualquer coisa, porque esse é o único estado em que eu
quero estar se eu voltar, desde que eu seja uma bola de espinhos ,
obviamente, o que é esse objeto Desde que eu volte ao meu jogo e
consiga ver no minuto
em que
recebo uma bola de espinhos, vejo que a animação
está realmente funcionando perfeitamente e faz com que o
jogo pareça muito melhor Talvez eu tenha que
movê-los um pouco porque eles ainda
estão bem próximos. Tudo ainda é bastante grande, mas na verdade está
muito bom por enquanto. E as bolas de cuspe estão se animando exatamente como
precisamos. Esse também é o momento da
animação que teremos para o resto de
nossos inimigos. Vamos voltar aqui para o nosso robô e começar, primeiro
animando este Vou deletar o colisor de
círculos e
vou mudar isso
para robô sprite Então, exatamente a mesma
coisa acontece antes. Isso vai criar
um animador para mim, eu vou para a animação
Assets Chame isso de animação de robô. Então eu acho que tenho quatro robôs sprites
diferentes. E eles simplesmente serão
a roda girando. E os olhos
mudam ligeiramente de cor. Aí estamos. Podemos ver que em
ação aqui, a roda obviamente
vai girar. E os olhos, e
se você pode ver, eles mudam ligeiramente de
cor e voltam. Essa será
toda a animação de que precisamos para nosso robô. Agora temos nosso
robô resolvido. Vamos fazer exatamente a mesma
coisa com a última, que
será nossa bateria. E esse vai ser
um pouco mais complicado. Vamos primeiro começar indo. Fiquei chocado
nos arquivos, não
sei por que, mas esse
será o começo
de nossa bateria Temos essa
bateria aqui. A forma como
essa animação vai funcionar será
um pouco diferente. Sim, a razão pela qual digo isso
por último é bastante específica. Ainda teremos
apenas uma animação, mas será uma
animação com um pouco de
lógica de uma
forma diferente da que tínhamos antes. Vamos chamá-lo de ponto da bateria. Basicamente, não
queremos animá-lo. Digamos que um bom tempo, digamos 3 segundos. Não queremos que nada
aconteça nos primeiros 3 segundos, só
queremos continuar usando
esse sprite. No momento, estamos prontos para chocar um, vamos
ficar lá Então, os 3
segundos minutos acabam em quatro. Nos próximos 2 segundos, queremos fazer a animação de
choque, que eu tenho
sprites aqui Apenas certifique-se de
que sejam 3 segundos. Nos próximos 2 segundos,
faremos isso
e, em seguida,
voltaremos ao normal. Na verdade, não precisamos colocá-lo depois, porque ele
vai funcionar por nós Mas então, durante o próximo
meio segundo aqui, minutos 3 segundos
acabam, e podemos usar essas pequenas coisas para
pular para a próxima coisa Um quadro depois,
queremos mudar
para essa nova animação
aqui, que é chocante, dois. E podemos ver se aí
começamos a mudar a animação. E aí, de 1 segundo,
ou melhor, um quadro após 3 segundos
até 20 quadros depois. Vamos
querer entrar nesse, vamos querer
mudá-lo e depois voltar para
este aos 40 e
depois mudá-lo novamente. Podemos ver que vai
ficar assim. Acho que deveríamos
tê-lo mais uma vez. Troque. Acho que essa
é a moldura que queremos. Isso é errado,
desculpe, eu copiei o mesmo duas vezes.
Deixe-me colocá-lo lá. Então, aqui, vamos
querer terminar a animação. Então, ele vai ficar parado por 3 segundos e então ele
vai ficar ativo, e então ele vai
parar novamente. E então, 3 segundos depois
, ele vai se mover. E essa será a
essência do nosso sprite aqui. E, na verdade, também será
assim que o inimigo funcionará. E temos que adicionar um pouco de lógica
a essa animação, porque finalmente
conseguimos fazer isso funcionar bem. Mas precisamos ter
algo que diga ao jogo quando ele está nesse
estado e quando não está. Vamos usar
aqui o que é chamado de eventos. Então, vamos garantir que exibamos exatamente um quadro após 3 segundos. Vamos adicionar um evento aqui. E também logo no final
da nossa animação aqui. Ou melhor, na verdade,
vou
colocá-lo no início do novo,
só para que o tenhamos
aqui logo no início do nosso quadro para ter
mais um evento aqui. E eu vou
explicar como eles funcionam, mas basicamente
existem maneiras de acessar o código anexado a
esta bateria para dizer, ok, sim, isso agora tem estar ativo e isso é o que você tem que
fazer neste momento. Vou começar
adicionando meus aceleradores. Agora explique como vamos
fazer essa bateria funcionar, mas na verdade será
bem simples. Vamos começar adicionando
o colisor a isso. Na verdade, vamos adicionar
um colisor de caixas. Essas são todas as
partes que queremos ser no minuto em que a coisa
chocante estiver ativa Você não quer ser
capaz de tocar em nada
disso, essa parte toda aqui, bem
como essa aqui, que será a
própria bateria. Perfeito. Só
vou me certificar de definir esses dois gatilhos Obviamente, se esse fosse um
inimigo sozinho, seria completamente
impossível se esquivar, porque não
há como você não
tocar em nada disso Mas é aí que
os eventos serão úteis. Só
teremos esses planadores ativos durante esse período porque ambos
são gatilhos,
então, obviamente, vamos examiná-los de
qualquer maneira Mas durante esse período,
eles
estarão ativos e, quando
esse período terminar, eles não estarão
ativos novamente. Na verdade, vamos
codificar isso rapidamente. Vamos criar um novo script. Vamos chamá-lo de script de bateria.
Vamos carregá-lo. E também teremos que criar um roteiro para outro
inimigo, o robô, que eu
vou encontrar em um minuto. Mas vamos primeiro fazer
esse script de bateria. E, na verdade, teremos
dois vazios simples. Se houver um vazio público, desligue a bateria. Vou criar outro embaixo e
chamá-lo de bateria ligada Vamos criar uma referência
para nossos dois planadores. Caixa pública, slide dois D, vamos ter a caixa
um e chamá-la de caixa dois. Tudo o que esses garotos vão
dizer é que quando a bateria está ativada, a
caixa um é igual a falsa, caixa dois ativada é igual a falsa, então vamos fazer exatamente a mesma coisa com
a bateria ligada, exceto
configurá-la O que vou dizer é que no minuto em que eu chamar
esse vazio aqui, bateria ligada habilita esses dois
planadores Mas no minuto em que eu
chamar esse vazio
aqui, a bateria desative-os. Na verdade, vamos começar
com eles desativados também. Isso vai dizer que, no minuto em que esse objeto aparece, ele não tem nada ativo Mas no minuto em que essa
animação chocante estiver sendo reproduzida, queremos que ela esteja ativa
e ativa E como é uma etiqueta inimiga, então vamos
codificar logicamente:
ok, você tem que sofrer danos Mas quando isso acabar,
queremos que isso acabe novamente. Vamos voltar à
nossa animação aqui. Vamos voltar ao
nosso evento aqui. E, na verdade, podemos
escolher uma função para chamar aqui, mas tem que ser uma função
de um script anexado. Então, vamos arrastar
nosso script de bateria. Vamos direto para o
fundo e colocá-lo ali. E podemos ver aqui que temos nosso script de bateria ali mesmo. Temos o script da bateria aqui, que está escrito lá embaixo, e temos nosso script real. Descobri que, às vezes, quando
você adiciona coisas com nomes como
script de bateria ou algo
assim, pode ocorrer
um erro que diz
: oh, não conseguimos encontrar o script. Certifique-se de que a classe exista. E pode ser
porque você nomeou seu script ou palavra reservada. Por exemplo, eu quero tentar
chamar minha única câmera de script. E continuei recebendo um erro e não
sei o que é. É porque você não pode
realmente usar a palavra câmera. A maneira de resolver isso
é, na verdade,
mudando essa palavra aqui
e essa palavra aqui. E é assim que você
renomeia seu script. Se eu estava preocupado com isso, porque cometi
alguns erros no passado, pensei que tinha acabado de mencioná-lo. Vou chamar isso de bateria. Então, isso vai me
dar um erro aqui porque agora ele não sabe
realmente o que
é a bateria ou
não sabe, mas deveria. Então eu vou passar
aqui para bateria também, e vou
renomeá-la para bateria E certifique-se de
renomear os dois. Certifique-se de renomear o
nome do arquivo e o nome real da
classe dentro do arquivo E então você deve
ter o problema resolvido. Se você encontrar algum problema
durante todo o desenvolvimento, é assim
que você o corrige. Mas de qualquer forma, isso deve
ser tudo o que precisamos. E vamos adicionar nossos
planadores de caixa ali mesmo. Vamos voltar à nossa animação, que abrimos aqui. E vamos ao nosso
evento e escolher
esses métodos de bateria de eventos. E então escolhemos a bateria
desligada para começar. Somente aqui
escolhemos bateria ligada, bateria lá e
bateria desligada ali. Na verdade, isso deve
funcionar perfeitamente bem. Agora criamos um prefab
com nosso script aqui. Enquanto essa
animação estiver sendo reproduzida, no minuto em que chegar a
esse ponto aqui, ela chamará esse vazio e ativará
esses aceleradores. E você não verá
isso aqui, mas
verá quando estivermos realmente
jogando o jogo. Então você pode ver que
realmente deve funcionar perfeitamente bem, o que
é muito, muito legal. Vamos voltar e
voltar para nossos pré-fabricados. Ainda temos
mais um pré-fabricado aqui, que são robôs pré-fabricados, que ainda não
terminamos Vamos adicionar um box collider two D. Vamos redimensioná-lo
um pouco aqui Lembre-se de que
não será
realmente onde ele poderá
cair, etc Vai ser
onde está a caixa de sucesso. Vamos torná-lo um
pouco menor que. Normalmente, assim como temos
o tempo todo, mas não muito pequeno, porque queremos que
ele seja capaz de bater, especialmente com essas
coisinhas vermelhas. Na verdade, vamos mudar
isso um pouco para baixo. Isso deve ser bom por enquanto. Vamos nos certificar de
configurá-lo para ser acionado. Apenas certifique-se
de que todos os outros também
estejam configurados para
acionar caso tenhamos esquecido
alguma coisa, na verdade, que é legal, temos nossos animadores nesses dois e acabamos de colocar nosso
animador Temos nossos três inimigos
animados, bem
como nosso
Spike, que é o único que
não animamos Na verdade, isso é praticamente
tudo o que precisamos fazer exceto adicionar alguma lógica
para nosso patrulhamento de robôs, porque esse é um inimigo
patrulheiro Antes de fazermos isso, vamos
criar mais alguns pneus rapidamente apenas para mostrar
contra esses novos inimigos. Não vou fazer
muitos, mas obviamente você pode adicionar mais
alguns. E só por uma questão de tempo, vou adicionar um pouco mais entre este e o próximo vídeo. Mas certo. Vou
fazer três só
para mostrar esses novos inimigos E eles vão
ser muito chatos. Todos eles terão
apenas um robô
ou robô , e o que é mais chocante Então, esta aqui,
na verdade, vou
usar apenas uma
dessas baterias. Coloque-o ali. Agora, obviamente, meu inimigo de bateria é
muito difícil de ver. Se eu fosse colocá-lo como eu normalmente gostaria de
algo assim, então você realmente não
conseguiria ver o fio, o que o
torna muito difícil. Então, vou
colocar isso na frente, vou dizer ordem na
camada até seis, ou melhor, sete. E vou
fazer com que
fique na frente de
todo o resto na nuvem. Parece um pouco estranho, mas podemos ajustar isso à medida que avançamos Só faz com que seja um
pouco mais fácil de ver. Vamos subir. Eu acho
que isso deve ficar bem. Obviamente, como eu disse,
podemos ajustá-lo à medida que avançamos,
mas, por enquanto, isso deve ser muito bom como
inimigo no jogo Esse é o nosso
piso 11, eu acho. Vamos nos certificar de que
vamos até o piso 12. E vamos adicionar um único
robô ali mesmo. Deveria ter diminuído um pouco porque obviamente podemos
ver sem isso, vamos garantir que
ele esteja sempre andando no chão.
Sim,
isso deve ser bom. Então, por último, teremos
, digamos, um robô e um espigão Só para mostrar que você obviamente pode
usar vários por item. Isso deve ser tudo o que
precisamos fazer. Agora, a última coisa que precisamos realmente
fazer é apenas codificar nossa lógica para o robô
patrulhando de um lado para o outro Vamos usar
uma coisa bem fácil aqui. Vamos apenas
ter uma variável aqui que define os limites. Patrulhe dois lá e
patrulhe dois lá. E então teremos um código
que diz, ok, enquanto eu
estiver me movendo,
contanto que eu esteja inclinado dessa maneira, contanto que menos do que
isso, mova-se dessa maneira. E eu vou te mostrar exatamente
como escrever o código. Mas antes de fazermos
isso,
precisamos realmente adicionar um corpo rígido,
nosso robô, para que ele possa se mover Mas queremos ter
certeza de configurá-lo um corpo rígido cinemático que ele não caia Como ele não tem um colisor real
acoplado a ele, ele simplesmente se move de
acordo com o código Então vamos para Scripts
e vamos
escrever rapidamente nosso script de robô muito
simples. Chame isso de movimento de robô. Vamos
clicar duas vezes nele para abri-lo. Então, tudo o que precisamos
fazer, como eu disse, é definir, em primeiro lugar, vamos fazer uma flutuação chamada velocidade para a
velocidade com que ele vai Então vamos
ter dois carros alegóricos. Vamos chamá-la de min x e max x, que basicamente serão
as duas posições onde ele poderá ir. Então, vamos
ter dentro de nossa correção, atualizá-la aqui. Vamos codificar
em nosso corpo rígido. Vamos tornar
público, Richard,
corpo dois, D, chame-o de R B. Então vamos dizer RB,
velocidade é igual ao vetor
três, vetor Vamos querer
definir nossa velocidade aqui para alguns valores x. Vamos criar mais uma
variável, chame-a de X. Então, queremos nossa velocidade RV Y dois B zero sempre porque
não vamos nos mover para cima
e para baixo com Então, a última coisa que
precisamos fazer é aqui
neste quadro de atualização. Precisamos dizer se a posição de
transformação x é menor que nosso valor
mínimo de x. Em outras palavras, se
ultrapassarmos nosso valor mínimo de x
, precisaremos fazer duas coisas. Em primeiro lugar, precisamos ter certeza de que estamos
voltados
para o lado certo e
giraremos o robô
da mesma forma que
fizemos com a rotação trans
stop do jogador é quaternion.u0 0.0 Então, a segunda coisa vamos fazer é
definir nosso x como nosso
valor positivo de velocidade. Caso contrário, escreveremos um curso L s
e diremos
se a posição do ponto de transformação x é maior que nosso máximo x. Em outras palavras, se não formos
menores que nosso x mínimo, mas não somos maiores que nosso x
máximo porque
também não
queremos ser muito grandes. Muito longe, certo? Em outras palavras,
vamos copiar essa coisa exata
aqui e mudar esse valor para 180 e
isso para velocidade negativa. O que esse código vai
fazer é dizer que, a cada verificação de quadro, eu não estou abaixo desse limite
mínimo. Se eu estiver, então me dê meia volta. Se eu for maior que
esse limite máximo, em outras palavras, se
eu não for
maior que o
limite mínimo, isso é ótimo. Mas isso implica que eu sou
maior do que os limites mínimos. Eu poderia estar me movendo para
a direita. Se eu for maior do que o
outro limite, então me vire para o outro lado. Na verdade, esse deve ser
todo o código de que precisamos para escrever nossa lógica de robô. Vamos até o robô. Vamos adicionar o script
aqui. Movimento do robô. Vamos garantir que atribuamos
o corpo rígido ali. Eu quero escolher uma
velocidade inicial de algo como cinco, então esse mínimo X, Y, na verdade
vou
escolher com
base no ladrilho desse primeiro ladrilho. Acho que quero que meu x mínimo
seja -2,9 Vamos aqui. É no mínimo x -2,9 Estou assumindo que meu x
máximo será
bem próximo de Sim, vou
fazer com que seja 2.8 Na verdade aqui meu x máximo é 2,8.
Você pode ver aqui, isso está em negrito porque esses
são valores que estou editando para este exemplo específico
do modelo, a instância
específica. Mas está tudo bem,
isso é realmente o que você quer. Essa variável x
obviamente dependerá das velocidades. Veremos essa mudança à medida que avançamos. Mas a última coisa que posso fazer para
ver esses robôs em ação é
que, na verdade, vou
mudar rapidamente o script da torre do mapa. Vou fazer com que tenha
apenas dois elementos para que eu possa testá-los. Primeiro vou colocar o meu com o robô aqui. Tow, na verdade vou
colocar os dois Rob e agora, porque essa é a
única maneira que testei, só para ter certeza de
que funciona, vou clicar em play Veja se eu encontro algum erro. Pode haver algo
que possa acontecer onde eles estão, isso é o que
eu pensei que poderia acontecer. Então, as estradas, na verdade,
estão
voando das nuvens,
porque nos
referimos a uma posição específica
aqui quando escrevemos o código. E colocamos isso nesse prefab, vemos que temos esses valores
aqui que dizem, ok,
contanto que você não seja menos
do que isso e menos do que isso, mas o que estamos esquecendo
é que esse é na verdade um objeto filho desse objeto pai
maior Então, isso é escolher
um ponto no espaço, não um ponto de referência
para essa nuvem. Para corrigir isso, tudo o que precisamos fazer mudar isso para
transformar a posição local ponto x. Alterar isso para transformar a posição
local em x. Então eu realmente percebi que
troquei esses Então isso deve ser 180, isso deve ser zero porque é aqui que estamos
avançando e é aqui
que estamos retrocedendo Então, a última coisa que
queremos fazer é ir até aqui e,
na verdade, adicionar nosso vazio inicial novamente Queremos começar definindo
x igual à velocidade porque essa variável x indica
se estamos nos movendo e ela só é atribuída
se excedermos um
dos limites Também queremos configurá-lo
no início. Todas essas mudanças que
acabamos de fazer fizeram sentido. Não se preocupe muito com
as posições locais. Mas, basicamente, não estava
funcionando porque estávamos nos referindo a
posições globais quando na verdade, queríamos posições
locais. E acabamos de adicionar esse ajuste. Então, começamos nos movendo também e nos certificamos de
virar na direção certa, porque esse foi realmente
um problema que tivemos. Hum, então vamos continuar e
voltar ao nosso jogo, e vamos ver se isso funciona agora. Espero que tudo esteja bem. Você pode ver aqui
que temos um robô. Annie está caminhando até o fim. Annie realmente se
vira, o que é perfeito. Se eu conseguir
me atualizar, não sei se
vou
conseguir sobreviver. Então, vamos
começar de novo. Devemos ser capazes de ver nosso
jogo agora com nossas animações E tudo pode correr bem e podemos nos
deparar com esses robôs, e obviamente
teremos que tentar evitá-los Mas isso é meio legal. É um ótimo novo inimigo
para se ter em nossos jogos. E eles estão meio que
patrulhando ao lado. Obviamente, eles não
terão essa aparência porque estão todos
meio que sincronizados agora, o que torna tudo muito mais difícil. Mas à medida que adicionamos peças e coisas diferentes
e definimos posições diferentes,
tudo vai ficar bem. Vamos
abrir esse novo. E, na verdade, vai
ser um pouco diferente. Vou querer que
este pare por aí, que é -1,17.
Vou definir o y
máximo para 2,72 Fora isso, tudo isso
deve ser bom. A última coisa que precisamos testar é essa placa de bateria aqui. Então, vamos voltar ao
nosso jogo e garantir que
adicionemos o bloco da bateria, 11 A, e ver se
funciona perfeitamente bem. Vamos testar
se, na verdade vamos pausar
o jogo e examinar as tags para garantir que tudo esteja funcionando conforme necessário Então, atualmente
temos um robô para começar, um robô depois disso. Espero que tenhamos uma bateria em breve. Parece que temos uma bateria, então atualmente a mecânica de choque parece estar funcionando Mas teremos que
fazer um teste mais completo. Vamos fazer uma pausa agora
porque
agora é quando os colisores
devem estar ativos Vamos até
aqui até este pneu de chão. Vamos até a
bateria. E vamos ver. Ok, os dois colisores estão ativos. É exatamente o que queremos porque agora o
inimigo é isso. Vamos fazer uma pausa e esperar
até que pare. E podemos ver que ambos
estão desativados. Então, isso é, na verdade,
tudo o que
precisamos concluir agora
para nossos novos inimigos. Como eu disse, obviamente você pode fazer um monte de pneus novos. Acabei de fazer alguns agora, mas
farei mais alguns para
o próximo vídeo, para que tenhamos um jogo um pouco mais variado. Você pode fazer
quantos quiser, especialmente com esses novos
inimigos que adicionamos agora devem ter um monte de coisas
extras que você pode fazer. E podemos
nos deparar com um ou dois insetos com esses novos inimigos
à medida que avançamos. Como são novas
adições aos nossos jogos, veremos como podemos ajustá-las
paralelamente Mas espero que esteja em um estado bastante
estável no momento. Não encontrei nada
que faça com que não funcione. Então, espero que
tudo esteja bem
no momento e que seu jogo esteja funcionando
tão bem quanto menos Começaremos nos próximos vídeos sobre como
adicionar a detecção de acertos,
bem como um sistema de saúde real. Portanto, temos um jogo em que você pode realmente perder e reiniciar. E então, na verdade, teremos que adicionar todas as coisas adicionais,
como pós-processamento e conserto do céu, e todas essas coisas para
fazer com que o jogo pareça um pouco melhor
do que está agora. Mas espero que você tenha a base para uma plataforma
bem legal, um jogo escrito em Unity Até agora, temos atualmente
12 ou 13 peças diferentes. E vou adicionar
mais alguns agora, como eu disse, e isso deve
permitir que você crie uma plataforma bem variada e
interessante novamente. Portanto, um bom trabalho assistir a este vídeo
foi bastante difícil, especialmente
alguns conceitos novos. E temos um inimigo
patrulheiro e um inimigo que só está
ativo em determinados momentos. Mas espero que você tenha
conseguido acompanhar. E nos vemos
no próximo vídeo, onde
começaremos a adicionar a Detecção de
Acertos. Obrigada.
10. 9. Apresentando a detecção de acertos: Olá, e bem-vindo de
volta à Unity. Agora, no último episódio, adicionamos um
monte de novos inimigos, além de animar
alguns inimigos que já
havíamos
adicionado ao jogo E então, basicamente,
fiz
um monte de alguns blocos novos para
testá-los e garantir que
todos funcionem perfeitamente. Eu te disse que se você quiser
adicionar mais blocos, você pode. E, como eu disse, fiz mais
alguns blocos entre
o último vídeo e este. Agora eu tenho o bloco completo, 13 A, e ainda não
o nomeei, mas 141-516-1718 19.20 Então a primeira coisa que precisamos fazer é realmente consertar
nossa faixa de desova
para que nossa faixa de desova Porque a última
coisa que
mudamos foi que estávamos apenas testando
os novos, mas agora queremos ser
todos eles novamente. E como eu disse,
eu tenho 20 agora. Então, vamos adicionar rapidamente tudo
isso a essa lista. Depois de adicionarmos tudo
à lista de blocos do mapa, poderemos
clicar em jogar e ver o jogo inteiro com todas as
novas peças adicionadas. Eu fiz alguns, como
um com dois robôs, um com duas dessas coisas de
bateria. Obviamente, você
teria que pular lá. Isso seria muito difícil. Talvez tenhamos que
ajustar a duração dessa animação porque
ela é bastante regular Ou talvez eu tenha que mudar
o bloco real em si. Mas atualmente isso
parece muito bom até agora. Na minha opinião, também temos
esses 12 robôs. Sim, eles são obviamente
muito difíceis de evitar, mas essa será
a base para os bloqueios que
teremos no meu jogo O que eu preciso
adicionar agora é um sistema de detecção de ocorrências. Porque atualmente
está tudo bem. Mas você não pode morrer. Você nem
pode perder o jogo. Na verdade, mesmo que você pule do mapa inteiro, você não pode perder. O que vou
começar
neste vídeo é fazer com que a detecção de
acertos funcione. E então, no próximo
vídeo, vamos começar com um sistema de
saúde e
vamos criar um sistema de saúde e a capacidade de realmente morrer. Mas neste episódio, tudo o que
vamos fazer é
a detecção de acertos, que na verdade é bem simples. Então, tudo o que
precisamos fazer é criar um novo script. Vou
chamá-lo de Player Health. Vamos abri-lo. Na verdade, tudo que
vamos adicionar aqui é um vazio para garantir que saibamos quando
estamos sofrendo danos Vamos começar com todas as outras
coisas de saúde mais tarde. Agora, tudo o que precisamos é de um vazio
público, sofrer danos. Vamos fazer o que é
chamado de parâmetro, que é como um valor que você
pode passar para um vazio Agora, como eu disse, um
vazio é um método, é um bloco de código
que você pode chamar Esse parâmetro é um valor
que você pode colocar nesse bloco. Quando você ligar, eu
vou dizer em danos. Então, toda vez que eu chamo
esse bloco de código, eu posso escolher quanto
dano eu quero causar. Em outras palavras, eu
posso escolher o que eu quero que esse valor seja. Eu vou me
livrar disso. Eu só vou escrever o Print Player. Então, vou colocar meu dano de
dano variável totalmente interrompido. Adicione um espaço ali e eu vou me certificar de
que diz duas strings, então é o
tipo correto de variável. Agora, isso está usando algumas coisas que
na verdade não abordamos. Como eu disse, parâmetros
e dois métodos de string, mas isso não é tão importante. Basicamente, como eu disse, um método é algo que você pode chamar em um
determinado momento e o código dentro dele executará todo esse número inteiro aqui
, dizendo que quando eu chamo isso, eu também posso escolher um valor Então, agora eu posso escolher coisas
diferentes, posso causar diferentes
quantidades de dano. Por exemplo, talvez um robô
possa causar dois danos, mas um espigão só causa um Então, tudo o que
faço quando
ligo para isso é dizer que imprimo na tela. Eu digo que esse jogador sofreu e depois dou a quantidade de dano
que recebi. Então eu escrevi dano. E como é um número inteiro, tenho que alterá-lo para uma string Se eu quiser usá-lo
em uma declaração impressa
, digo danos. Agora, na verdade, tudo que eu preciso fazer é criar um novo vazio Vou chamá-lo de vazio
no gatilho dois D e,
na verdade, é muito semelhante ao
vazio de colisão que
usamos antes, exceto
que são apenas quatro aceleradores configurados para
acionar, que são todos os que
usamos Vamos dizer se colision game object dot compare tag, exatamente como fizemos antes Desta vez, se for
um inimigo do tipo tag, o que queremos
fazer é acessar
agora a quantidade de
dano que precisamos causar. Para fazer isso,
precisaremos escrever outro script. Vamos até aqui e
vamos criar um novo script, chamado de informações do inimigo. Dentro do script, vamos criar várias variáveis. É como uma
coluna de estatísticas para o inimigo. Então, vamos
criar um T público, então vamos
chamá-lo de danos ao jogador. Vamos adicionar o script a cada um dos nossos inimigos. E então, toda vez que
colidirmos com um inimigo, veremos
esse script com
o inimigo específico com o qual
você colidiu E é daí que
vamos obter nossa variável de dano. Isso pode parecer um
pouco confuso, mas tenha paciência comigo. Se colidimos com
algo que é um inimigo, diremos colision dot game
object dot get component Em outras palavras,
anexe um componente ao que
acabamos de colidir Colisão é o colisor com o qual
acabamos de colidir. Se o objeto do jogo ao
qual está anexado, em outras palavras, nosso
inimigo for um inimigo, então vá e pegue outro script
anexado a esse inimigo
, chamado de informações do inimigo. Parênteses depois disso.
Depois disso , causamos danos ao jogador. Agora podemos acessar a
variável explicitamente. Basicamente, essa declaração não está
realmente fazendo nada, mas diz que causa dano ao
jogador de qualquer coisa com a qual
tenhamos colidido Agora, tudo o que precisamos
fazer é
colocar isso como nosso
parâmetro de dano. Então, vamos escrever para tomar dano em bloco aberto e vamos colocar
esse código aqui. Como eu disse,
mesmo que
tecnicamente sejam apenas duas linhas de código, pode
parecer um
pouco confuso, mas na verdade não é tão Tudo o que estamos fazendo é definir esse código aqui
que diz, ok, quando eu ligo para isso, quero
jogar, sofri tanto dano. Obviamente, vamos
detalhar isso mais tarde. Mas agora tudo o que ele faz é dizer, ok, um
jogador sofreu dano,
mas a quantidade de dano que
sofremos é determinada
por esse vazio aqui
no gatilho, digite dois D. Estamos dizendo que toda vez que
entramos em um colisor de gatilho,
se esse colisor estiver
acoplado a um inimigo,
então chame isso de sofrer por esse vazio aqui
no gatilho, digite dois D. Estamos dizendo que toda vez que
entramos em um colisor de gatilho,
se esse colisor estiver
acoplado a um inimigo, então chame isso Em outras palavras, execute esse código e defina a quantidade
de dano
que eu quero que atribuiremos ao
adicioná-la sofrer com a quantidade de dano armazenada nessa coluna de informações do
inimigo, que atribuiremos ao a cada
um de nossos inimigos. Vamos voltar para fora.
Entre em nossos pré-fabricados Aqui é onde todos os
meus inimigos estão guardados. E vou adicionar
informações do inimigo a cada
um deles. Informações corretas sobre o inimigo. Vamos fazer com que
a bateria não danifique. Acho que o robô
só deveria causar um dano. Acho que Spike
também deveria causar apenas um dano. E então eu vou fazer
com que a
bola de espigão também cause um dano Na verdade, é só a bateria. Ou talvez façamos com que uma
bola de espigão cause dois danos Apenas torne as coisas um
pouco mais interessantes. Agora, cada uma
dessas coisas tem script anexado
que armazenará quanto
dano ela causa. A última coisa que vamos
fazer é garantir que eles estejam prontos para marcar o inimigo. Parece que
estão. Agora tudo o que precisamos fazer é
voltar para o nosso jogador. Vamos adicionar esse novo script que
acabamos de chamar de Player Health. Coloque-o abaixo
do movimento do jogador. Na verdade, não precisamos
atribuir nada aqui porque não temos
nenhuma variável aqui. Acabamos de ter um vazio
que diz sofrer danos. Temos um evento. Sempre que colidirmos com o colisor,
sofreremos muitos danos Agora, o que deve
acontecer se
prosseguirmos limparmos o console
e clicarmos em Play? Podemos ver que nada
está impresso agora, mas à medida que
avançamos, vamos interagir com aquele Spipal
e ver o que acontece E podemos ver que o jogador
sofreu dois danos. Eu faço isso de novo, ele
roda novamente Aqui, jogador sofreu um dano. Aqui, o jogador sofreu um dano.
E vamos tentar fazer isso. O jogador sofreu dois
danos, dois danos, porque o jogador
sofreu dois danos, jogador sofreu um dano, um dano, um dano. Perfeito. Na verdade, isso está
funcionando muito, muito bem. Agora, a última coisa que
quero acrescentar, para
que o próximo
vídeo não seja muito longo, é um tempo de invencibilidade Na verdade, isso também é muito
fácil de fazer, porque esse é o script que
usaremos para toda a saúde de nossos jogadores. Vou começar a
detalhá-lo agora, mas basicamente tudo o que precisamos
fazer é recuperar nossa
atualização vazia.
Então, cada quadro. E então vamos pegar
um carro alegórico aqui em cima. Chame isso de tempo máximo de invencibilidade. Então
teremos outro carro alegórico
que será
chamado de tempo de invencibilidade Tudo o que vamos fazer é,
dentro dessa atualização vazia, dizer que se o tempo de
invencibilidade for maior que zero, diminuiremos
o tempo de invencibilidade
pela quantidade de tempo decorrido
desde o último quadro, o
tempo delta do O que vai fazer
é dizer cada quadro se
esse valor não for zero, em outras palavras, se
for cinco menos quanto
tempo passou
desde o último quadro Então, em outras palavras,
basicamente contagem regressiva. Bem, na verdade, isso só
vai funcionar como um tempo, mas vamos dizer que se
for maior que cinco, então conte até zero. E então tudo o que
vamos fazer é subjugar esse
vazio de dano Vamos adicionar outra condição
de declaração
if aqui no topo. Vamos dizer se
colidimos com o inimigo e nosso tempo de invencibilidade é
menor ou igual Em outras palavras, se não estamos atualmente em uma
época em que somos invencíveis Então, vamos adicionar mais alguns
parênteses
e só então sofrer danos A última coisa que vou
realmente fazer é remover essa palavra Enter e
alterá-la para uma palavra ficar. A razão pela qual podemos
fazer isso agora é que
esse evento de gatilho
aqui é, na verdade, chamado uma vez por quadro para cada colisão com
você que está se tocando Em outras palavras,
se eu colidir com alguma coisa e ficar
lá, danificarei continuamente
cada quadro Mas como adicionamos
esse tempo de invencibilidade, agora
podemos escrever
o código dessa forma e definir um horário em que
não possamos sofrer danos Porque a razão pela qual eu não fiz isso originalmente foi porque
teríamos visto 100.000 mensagens toda vez
que tocamos em algo. Porque vai rodar
em todos os quadros. Mas porque agora só estamos sofrendo danos
sempre que podemos. Em outras palavras, somente a cada
intervalo definido que
vamos definir aqui, não
podemos sofrer danos o tempo
todo. Agora eu posso escrever esse
código assim. Na verdade, isso é muito melhor porque
significa que, se
ficarmos em cima de um espigão ou
algo parecido, sofreremos
danos continuamente enquanto
estivermos nos E isso é realmente
o que queremos. Antes de realmente
voltarmos ao meu jogo, há uma última
coisa que preciso fazer. Preciso ter
certeza de que sempre defino meu tempo de invencibilidade
aqui igual ao meu tempo máximo de
invencibilidade desde que eu tenha No minuto em que eu sofrer dano,
reinicie esse tipo de tempo. Basicamente, esse é
praticamente todo o código que precisamos escrever para ter um
sistema básico para sofrer danos. Vamos voltar para o Unity. Vamos definir meu máximo,
meu tempo para 1,5 segundos. Vamos ver isso em
ação. Se eu for em frente e clicar em play, posso correr. E vamos realmente
observar essas duas variáveis. Assim, podemos ver se está funcionando. Assista a este. A cada 2 segundos, eu
vou sofrer danos. Você pode ver ali, o
jogador sofreu um dano, jogo sofreu um dano, o jogo
sofreu um dano fornecido. Eu fico nesses colisores. Na verdade,
sofro danos continuamente toda
vez que estou em um, que é exatamente o que eu quero Agora, há mais uma
mudança que eu quero fazer , desde que eu esteja ocupado
fazendo coisas no meu jogo. E ele adicionará
uma animação de detecção de acertos. Na verdade, vamos
até
meu jogador e poderemos animá-lo para que,
sempre que ele sofra danos, surja um certo efeito ,
etc., etc E escrevemos isso na janela de
animação aqui. Isso vai
complicar bastante as coisas , porque já
temos todas essas animações
aqui e adicionamos uma animação ferida Então precisamos nos machucar enquanto estamos ociosos, machucar enquanto corremos, etc Em vez disso, vamos
usar um efeito simples, que será um
bloco vermelho parecido com esse. Quando eu sofro dano e
depois volto. Eu vou piscar em
vermelho momentaneamente. E então eu vou parar. A forma como vamos
realmente fazer
isso é usando inteiramente códigos. Vamos ver aqui
no meu script de saúde do jogador, vamos escrever o que
é chamado de co-rotina. Então, vamos escrever o
numerador, sofrer danos. Isso
nos permitirá programar da
mesma forma que os cronômetros realmente esperam
por essa quantidade de segundos. Vou escrever
o seguinte. Eu vou dizer aqui
no topo vou ter uma referência
pública ao meu Sprite Renderer,
chame-o de Sprite Eu vou dizer que dentro da
minha tomada de dano está vazio. Não se confunda com
isso. Basicamente, pense nisso como um vazio Mas eu posso usar comandos que me permitem esperar por uma
certa quantidade de segundos. Isso não é
exatamente o
que é, mas é exatamente para isso que
vamos usá-lo. Pense nisso
como um vazio com uma habilidade extra, obviamente Não use isso em vez de espaços vazios. Use-o apenas da maneira
que estou usando agora, mas não se
preocupe muito com isso. Você vai dizer peso de
retorno de rendimento por segundos. Em seguida, vamos inserir uma
certa quantidade de segundos. Vou usar invariável para decidir que é isso que
vou dizer Horário de mudança de cor do carro alegórico público. Essa variável de tempo de mudança de cor
é o que vamos
usar para determinar quanto tempo
devemos esperar antes de
mudar as cores. Primeiro, vou usar sprite: a cor é igual à
cor branca. Depois,
vou esperar
por quanto tempo demore meu tempo de mudança de
cor. Então eu vou mudar de, na verdade, vou colocar
vermelho no topo daqui. Originalmente, fico vermelho, espero
alguns segundos e depois fico branco. E isso é, na verdade, praticamente tudo o que
precisaremos fazer. Vamos definir a cor
do sprite para vermelho no minuto que quisermos
e, quando
terminarmos de sofrer danos, voltaremos a
colocá-la em branco E, obviamente,
toda vez que sofremos danos, vamos chamar
isso de co-rotina. Agora, duas coisas. Em primeiro lugar, na verdade,
isso tem
o mesmo nome de vazios. Vou chamá-lo de take damage effect, em vez disso, é
um nome um pouco melhor. E em segundo lugar,
teremos que
invocar isso toda
vez que eu estiver
abaixo disso e escrever a rotina
start co novamente Não se preocupe muito com
essa coisa. Realmente não é tão
importante e eu realmente
não quero gastar
muito tempo estudando isso. Mas, basicamente,
pense nisso como um vazio que nos permite
esperar por um certo
período de tempo Então vamos
chamar esse vazio específico aqui, que
nos permite sofrer danos E isso significa que
toda vez que
sofrermos danos, mudaremos
para vermelho. E então, por
quanto tempo
quisermos ficar vermelhos, vamos mantê-lo. E então vamos
voltar ao branco. Isso é praticamente
tudo o que precisamos fazer para
ter um indicador de acerto. Vamos voltar para a Unity. Volte imediatamente para jogar. Vamos definir o
tempo de mudança de cor para 0,2 segundos. Agora, se tudo
funcionar como deveria, devemos ser capazes de correr como costumávamos. Como de costume,
quando sofremos danos, devemos mudar para vermelho. Não atribuímos um sprite,
vamos garantir que façamos isso. Arraste isso até aqui. Atribua a variável sprite
à coisa do sprite. Vamos tentar novamente,
correndo,
se sofrermos danos, piscamos em vermelho, que é exatamente o que queremos. E isso é realmente muito
bom na minha opinião. Você pode ver claramente quando
sofre danos e,
obviamente, se
ficar dentro dele,
sofre danos contínuos Isso é muito bom. A única última coisa é
por quanto tempo somos os quatro invencíveis e vamos
escrever outra
co-rotina para isso também Vamos até aqui e chamemos o
enumerador de tempo chamemos o
enumerador Em outras palavras,
diremos faça isso até que isso não
seja mais verdade. O tempo de invencibilidade é
maior que zero. Em outras palavras, embora
atualmente sejamos invencíveis. Vamos entrar e
sair da tela. Vamos fazer a mesma
coisa que fazemos com as cores. Vamos lá, a cor do sprite é
igual a uma nova cor. Vamos definir
essa nova cor para ser exatamente
como temos branco, exceto com um alfa um pouco
menos evidente. Vai ser um
pouco transparente. Defina isso como 111, que é o valor máximo, e então definiremos alfa. Vamos usar uma variável
para isso também. Transparência pública de carros alegóricos. Vamos copiar isso
e colocar lá. Na verdade, isso é
exatamente o que queremos. Embora esse
tempo de invisibilidade seja verdadeiro, vai mudar para in, nós
vamos mudar para
um pouco transparente E então vamos
escrever um novo retorno de rendimento para esperar alguns segundos. Vou usar outra
variável aqui. Vou chamar isso
de atraso de invencibilidade. Em outras palavras, quanto tempo queremos que seja o tempo entre os flashes Vamos escrever o
atraso de invencibilidade ali. E então vamos voltar
e colocar nossa coisa volta aqui, normal 1111 Na verdade, vou repetir esse processo algumas vezes. Em outras palavras, vamos
mudar a cor transparente, voltar para a cor normal e esperar por mais
alguns segundos. Depois de fazer isso, nos
tornamos transparentes. Esperamos, nos tornamos
normais, esperamos. E então, se
ainda somos invencíveis, nos tornamos transparentes novamente Espere, isso vai
se repetir indefinidamente, até que isso não seja mais verdade
e então vai parar. É importante observar
que, como escrevemos esse código, ele nunca vai parar
quando você for transparente. Como ele só
verificará se tempo de
invencibilidade é
maior que zero no
final desse código, ele não poderá
parar no meio do Ele vai rodar de
uma só vez e depois dizer, ok, eu preciso fazer isso de novo? Você precisa se preocupar em ficar
preso meio transparente. Agora, antes de voltarmos para o Unity, precisamos realmente
fazer uma coisa. Temos que ter certeza de que
realmente chamamos isso de cotina. Caso contrário,
nunca surtirá efeito e não poderemos
vê-lo. Vamos até o topo aqui. Lembre-se de escrever
em Start Corotine Invincibility Time,
assim Na verdade, isso nos
permitirá chamar a corotina. Certifique-se de colocar um
ponto e vírgula no final. Agora, se voltarmos para o Unity, podemos ter certeza de editar
esses valores em nosso player. Vamos fazer com que essa invencibilidade
demore 0,2 segundos. Vamos fazer com que minha transparência 0,5 tenha que ser um valor 0-1.
Lembre-se disso Agora, isso deve ser tudo o que precisamos para ter
um efeito de
invencibilidade que funcione corretamente Vamos ver se funciona.
Se eu carregar meu jogo, obviamente o efeito de
dano vermelho funcionou. Mas vamos testar se
esse também funciona. Você pode ver que realmente
funciona perfeitamente bem. Parece que
perdemos nosso efeito de dano. E a razão para
isso é porque,
na verdade, estamos substituindo nossa cor Vamos voltar aqui e fazer uma pequena correção
rapidamente. Não vamos
querer mudar isso. O que estamos acontecendo é que
estamos mudando para vermelho. Mas esse código aqui
está tornando-o branco novamente. Em vez de dizer, ok,
mude para branco, vou dizer que mude para o que era antes.
Cor do ponto Sprite Cor do Sprite. Cachorro Sprite dot cool. E para C vermelho, verde e azul, isso deve funcionar muito melhor. Agora, não vamos
mais mudar nenhum aspecto
real
da cor, exceto seu canal alfa, que
é exatamente o que queremos. Vamos voltar aqui e ver se
isso funciona um pouco melhor. E eu acho que
deveria ter certeza de
observar essa variável de tempo de intervinsibilidade Se sofrermos danos, podemos ver que realmente funciona
perfeitamente bem. Enquanto estamos fazendo a contagem
regressiva na hora do espírito, piscamos e, no
minuto em que paramos, paramos, o que nos dá uma
boa indicação de nosso jogo e do sistema de danos
estão funcionando, o que é ótimo. Isso é praticamente tudo o que
precisamos fazer neste vídeo. Obviamente, agora podemos ver que podemos realmente sofrer danos e tudo o que
precisamos para começar agora
é nosso sistema de saúde, que deve nos ajudar a tornar esse jogo muito mais
divertido e,
na verdade , mais parecido com um jogo
do que é agora. Então, espero que seu jogo esteja funcionando tão bem quanto
menos no momento Obviamente, precisamos
ajustar isso e garantir que tudo
esteja funcionando como menos antes de continuar com
o próximo vídeo, onde
começaremos com
nosso sistema de saúde. Obrigada.
11. 10. Adicionando a saúde do jogador: Olá, e bem-vindo de
volta à Unity. Agora, no último episódio, adicionamos a Detecção de Ataques,
que permitiu que nosso jogador
mostrasse quando sofreu que permitiu que nosso jogador
mostrasse quando sofreu dano e também por quanto tempo ele é invencível antes de
sofrer Novamente, podemos ver tudo
isso em ação aqui, com o
dano sofrido e o brilho, enquanto
você pode ver onde acabou de parar de sofrer danos e
agora está invencível E então,
quando passa, tudo bem, tudo bem, mas ainda não temos um sistema que realmente mostre, ok, quanta saúde eu tenho e
quanto tempo até eu realmente morrer? E o jogo acabou porque o jogador não
tem saúde infinita. Não seria um jogo muito
interessante se você nunca pudesse morrer. O que precisamos adicionar
neste episódio é um sistema de saúde
para mostrar, ok, o jogador ainda tem
tanta saúde, e quando o jogador atinge
essa saúde, ele morre. E para fazer isso, vamos usar
exatamente
o mesmo script que usamos o
tempo todo, esse script de saúde do jogador. Então, vamos entrar nos scripts e clicar duas vezes na
saúde do jogador para abri-los. No Visual Studio,
devemos ser capazes de ver tudo o
que codificamos da última vez Aqui mesmo.
Perfeito. Agora, tudo que
vamos fazer é
adicionar um int público, chamá-lo de Max health. Isso é algo que você realmente
não precisa adicionar a uma variável, porque
o que isso vai
dizer é quanta saúde
devemos ter no máximo. Em outras palavras,
quanta saúde eu quero quando estou com saúde plena? E você pode pensar, oh, isso é uma coisa boa de se
ter como variável. Mas como eu já fiz
os sprites e tudo mais, sei quanta
saúde máxima vou ter Serão seis, mas você pode adicionar isso
se quiser. De qualquer forma, também é uma boa
prática de programa. Mas vamos deixar
isso aí e também adicionar um novo público saúde
atual, que
será chamado de, na verdade,
ele a
chamará de saúde atual. Legal. Então, tudo o que
vamos fazer é ir até aqui para meu
vazio de dano aqui E eu vou dizer que a
saúde atual é menos igual. Em outras palavras, a
saúde atual é igual à saúde atual menos. E então vamos dizer que
o dano, em outras palavras, diminui saúde
atual pela
quantidade de dano. Na verdade, vou remover esta declaração impressa
aqui que diz quanto dano eu
sofri porque era
apenas para teste. Então tudo que eu preciso fazer
aqui é ter outro vazio embaixo disso que vou
chamar Vou chamar isso de vazio
no minuto em que eu sofrer dano, antes mesmo de causar
qualquer efeito
, tempo de invencibilidade
ou algo parecido Eu vou dizer que se minha saúde atual é menor ou igual
a zero, então eu estou morto. Preciso invocar outro vazio. Vou escrever aqui
embaixo, morte. Vamos
adicionar isso aí. Dano nulo quando eu diminuo minha saúde atual de acordo com a
quantidade de dano que recebi Meu cheque está
vazio quando digo,
ok, se minha saúde atual for
menor que zero, chame assim E eu tenho meu vazio de morte
aqui, que diz ok,
agora, quando eu estiver morto,
o que eu quero fazer, então eu vou realmente
começar, programar isso E então vou acrescentar
uma última coisa no topo aqui que diz,
ok, defina minha saúde atual para a saúde máxima
no início. Na verdade, vou fazer isso agora. Vamos
dizer que a saúde
atual do início vazio é
igual à saúde máxima. Em outras palavras,
está tudo muito bem. Estamos começando de novo e
minha saúde
atual está no máximo. Então, lá embaixo,
no vazio da minha morte, vamos dizer ok, o que eu quero que aconteça quando eu morrer Bem, a primeira coisa que
eu quero é não querer que o jogador
consiga se mover mais. A maneira como vou fazer isso é acessar o objeto do jogo ao qual isso está atualmente
conectado, que é o jogador. Vou acessar Game object e depois vou encontrar
outro script sobre isso. Em outras palavras, o script do movimento
Get. Vou usar o Player para obter o
componente de movimento do jogador. Eu vou dizer que
habilitado é igual a força. Em outras palavras, vou
impedir que esse script seja
habilitado no momento. Eu vou dizer que
está bem, acabou. O que isso vai fazer
é basicamente me
permitir desativar o movimento
enquanto Glary estiver morta Também não quero que
meu corpo rígido tenha alguma gravidade me afetar. Eu
não quero mais cair. Eu vou dizer para obter um
componente de corpo rígido escala de gravidade de
dois D. Vou definir
isso igual a zero. Em outras palavras,
não quero cair, estou no meio
do ar e
atualmente não consigo me mover. Depois, há mais algumas
coisas que eu quero fazer. Eu quero realmente desativar o animador que
está no meu componente, no meu objeto agora Agora não consigo mudar a animação. Então, por último,
quero mudar meu sprite para um sprite da morte
específico, que vou
colocar aqui Eu vou dizer que é um
sprite público, chame isso de morto. Eu vou dizer que obtenha o componente
Sprite Renderer Sprite igual Essas quatro linhas de código
aqui basicamente
vão dizer, ok, no minuto em que eu morrer, desabilite
meus scripts de movimento. Agora eu não consigo mais me mover
porque o jogo acabou, certo? Eu também não quero ser
capaz de cair, então defina minha gravidade para zero. Estou apenas suspenso
no meio do ar, sem me mover para
a direita Na verdade, vou acrescentar mais
uma coisa antes de fazer isso vou
dizer
que objeto do jogo, obtenha o componente corpo rígido dois, a velocidade D é
igual ao vetor 20 Em outras palavras, me pare no ar porque do jeito que
isso funciona atualmente, se eu morresse e fizesse todas essas coisas, continuaria a
me
mover pela tela, o que eu não quero Então, primeiro eu quero fazer com
que eu não possa me mover. Quero parar no ar
e desativar minha gravidade. Então, eu estou no
meio da tela. E, em vez disso,
no meio da tela, eu quero desativar meu animador Então eu não tenho mais
nenhuma dessas coisas, ok, se eu estiver no chão ou não,
esteja eu caindo,
estou apenas desativando
isso completamente E então vou
configurar meu componente do Sprite Renderer, o que me
diz o que os sprites atualmente exibem nesse
sprite especial aqui, que eu também vou adicionar Esse é praticamente
todo o código que precisamos para criar
um sistema de saúde. Eu vou dizer que, no início
do jogo,
defina minha saúde para o máximo de saúde. E então toda vez que eu
sofro dano menos dele, e no minuto em que eu morrer, chame esse Spoid aqui, que basicamente deixa
bem claro que eu Vamos abrir o Unity,
entrar no Player. Vamos ver quais
deles temos que adicionar. Vamos definir minha saúde máxima para seis e precisamos adicionar esses
sprites mortos Vou entrar em
sprites, clicar com o botão direito do mouse e importar com o botão
direito um novo ativo
e é menos sete Ele deve estar vinculado abaixo deste vídeo, assim como todos
os outros. Vou atualizá-los
enquanto estou realmente adicionado. Também vou importar
esses sprites cardíacos que usaremos em nosso sistema de
saúde daqui a pouco Vamos continuar e
torná-los também 12 e Point No
Filter and Perfect. Vamos verificar
como fizemos da última vez, certificando-nos de que ambos estejam preenchidos. Perfeito. Vamos
rolar até aqui e garantir
que meus sprites negativos configurados para menos sete Vamos ver se tudo isso funciona
exatamente como pretendíamos. Adicionamos nosso último sprite, todo o resto. Vamos até o meu jogador, podemos ver agora que
tenho seis pontos
de vida atuais e seis pontos de vida máximos. Agora minha saúde está em quatro
porque acabei sofrer danos, a saúde agora está em três. E se eu sofrer dois danos com isso, a saúde
será a mesma. Agora, o que deve acontecer se
eu encontrar o sprite? Eu deveria parar Miller e transformar em uma lápide, o
que é perfeito Ainda tenho o
efeito surdo que preciso corrigir. Mas você pode ver que,
obviamente, não
desativamos todos,
os scripts não estão totalmente mortos, mas essa lápide
parece estar funcionando Eu tenho uma lápide aqui, e tudo isso é muito legal Quero fazer mais alguns ajustes
antes de começar a adicionar
meu sistema cardíaco A primeira, acho que
a lápide deveria estar um pouco mais alta no
ar do que quando você morreu Vamos começar dizendo
aqui onde está todo o
resto desse código. Vamos também dizer que a posição da
transformação
é igual ao novo vetor três Transforme a posição x, ponto de oposição
transformado
y oposição transferida. Obviamente, essa declaração ainda
não faz nada. Só estou dizendo que oposição
transformada
é igual a oposição transformada. Mas então vamos até o topo aqui e
vamos adicionar deslocamento y para quando morrermos Vamos copiar isso lá embaixo, e depois vamos adicionar
isso aqui. E acho que algo
como dois ou três fará com que
pareça muito melhor. Depois de fazer isso, a última coisa
que
queremos fazer é adicionar
uma nova variável, chamá-la de “está morta”. E isso
nos permitirá acompanhar quando
estamos realmente vivos e não aqui no
início do jogo. Queremos colocar o que é
morto igual ao falso, porque não estamos
aqui quando morremos. Queremos que o
morto seja igual ao verdadeiro. A razão pela qual
vamos fazer isso é que vamos realmente
cuidar de todas as coisas que fazíamos anteriormente,
onde ainda estava
sofrendo danos e o tempo de invisibilidade
ainda estava afetando
todas essas coisas E o lugar em que vamos
colocar isso é na verdade, mover
esse script para cá. Vamos dar uma olhada no
meu roteiro de débito de cheques
aqui e dizer se saúde
atual é
menor que igual a zero morte. E então, abaixo disso,
antes de ligarmos para as outras coisas, diremos que se não está morto, em outras palavras, se
eu ainda estiver vivo, então você pode fazer todas
essas outras Então você pode definir a hora de início, você pode invocar as coisas
danificadas Mas se acabamos de morrer, realmente
não queremos
que isso aconteça. Na verdade, também poderíamos colocar
isso como uma declaração L. Você poderia dizer outra coisa,
em outras palavras, se minha saúde atual não
estiver lá, que vou fazer apenas para melhorar um pouco as condições, mas isso realmente não
faz diferença Na verdade, essa variável morta não
é 100% necessária aqui
porque poderíamos simplesmente escrever outra coisa e depois
não usá-la. Mas acho que ainda é
bom saber
se o
jogador está vivo ou não. Vamos voltar ao player e meu Y compensar algo como dois e ver se todas essas
mudanças vão funcionar Vamos clicar em jogar e ver
se eu recebo danos continuamente. São dois, são
quatro, são cinco. No sexto,
podemos ver lá, dois podem estar um pouco altos,
vamos configurá-lo para talvez um. Mas, na verdade,
funcionou perfeitamente. Temos tudo
funcionando bem. Se morrermos na frente de
algo parecido com um espigão, entraremos na frente do espigão, mas não continuaremos
sofrendo danos nem exibiremos danos Vamos deixar o robô nos
matar. Quase. São quatro. Portanto, se
morrermos aqui, lá vamos nós. Devemos ver ali,
temos nosso efeito de morte ali. E também queremos que
a câmera pare. Mas vamos
adicionar isso agora. Vamos até aqui até minha câmera. Vamos descobrir onde
está aqui. Velocidade da câmera abaixo do roteiro de movimento da
câmera, abaixo desse
vazio morto aqui Eu vou dizer game
object dot find. Em outras palavras,
entre na cena, minha câmera principal, encontre-a. Então dizemos get component, descubra que o
script de movimentação da minha câmera definirá minha velocidade, a velocidade
da câmera igual a zero. Na verdade, isso é
tudo o que precisamos. Agora, no minuto em que
eu morrer, devo ter a
velocidade da minha câmera ajustada para zero e tudo deve
funcionar perfeitamente bem. Vamos voltar ao meu jogo. vou querer
ajustar meu deslocamento y Na verdade, vou querer
ajustar meu deslocamento y para algo como 0,5 Acho que um ainda estava
um pouco alto Vamos ver se
tudo isso funciona exatamente como prevíamos. Por uma questão de teste,
na verdade,
vou definir minha saúde como uma, tenho que
continuar testando isso. Vamos definir a
saúde atual. Você vai até um e vê se
encontramos com aquele pico. Podemos ver que de fato morremos e a câmera para, o
que é ótimo. É exatamente o que
queremos. Isso é praticamente tudo o
que precisamos fazer
para mostrar
que estamos morrendo. Mas ainda precisamos de uma
maneira de o jogador
ver quanta saúde
ele ainda tem. Para começar com
isso, precisamos
começar com nossa interface de usuário. Vamos clicar com o botão direito do mouse e clicar em Criar. Eu vou querer
criar uma imagem. Você pode ver que isso cria uma tela
enorme e,
na verdade, é muito maior do que isso. Tem nosso jogo lá embaixo. Isso pode parecer um
pouco confuso. Essa é uma sobreposição de espaço na tela. Eu prefiro muito mais usar o modo de câmera espacial da
tela. E você pode arrastar sua câmera
diretamente para lá e ver sua interface de usuário na
frente do jogo. Não há
muita diferença, é apenas uma questão de preferência. Mas geralmente prefiro usar o espaço da tela, o modo câmera. Acho que existem algumas vantagens
distintas, mas nunca as
pesquisei muito
porque nunca tive
problemas com o modo de câmera Vamos usar a câmera dentro dessa imagem aqui. Vamos primeiro renomear
nossa tela para UI. Essa tela é como um alicerce para todos os componentes
da interface do usuário. E esse sistema de eventos
nos permite que os botões funcionem. Tudo isso será criado automaticamente quando você
criar uma nova imagem, assim como o animador foi
criado quando você criou,
ou melhor, o
controlador foi criado quando você criou uma animação Deixe todos eles.
Não os exclua. Deixe o
sistema de eventos onde está e deixe a
tela da interface do usuário como está. Obviamente, sem a tela, nenhuma dessas
imagens
vai realmente funcionar e elas
não vão aparecer. Se o movermos para fora da tela, podemos ver que ele não é mais
renderizado em nossa tela Vamos deixar
tudo como está. Mude isso para coração, então vamos seguir em frente
e arrastar nosso coração. Para a imagem de origem,
clicaremos em
Definir tamanho nativo para que possamos
ver exatamente como ela funciona. Parece que está renderizando apenas uma parte específica
do meu sprite cardíaco Acho que a razão para isso, se olharmos para essas
setas aqui, podemos ver que
há três coisas que aparecem, ao contrário de todo
o resto que só tem uma Por alguma razão, o
Unity automaticamente acha que está sendo
inteligente e tenta separá-los em
três sprites diferentes quando, na verdade, eu só
quero que eles sejam um Vou selecionar
todos eles.
Certifique-se de definir o
modo sprite para aplicar com uma única cabeça Então, se eu voltar aqui e tentar arrastar meu sprite, tudo funcionará muito melhor Na verdade, não percebi
que isso seria um problema, mas
certifique-se de fazer isso, especialmente se estiver usando meus sprites Agora, acho que muitos
deles estão, na verdade, definidos como múltiplos por padrão. Mas
isso nem é um problema. Por exemplo, esse menor é múltiplo, mas é apenas um. Na verdade, acho que
cada um dos meus outros sprites
é na verdade um, mesmo que estejam
todos configurados para vários Portanto, isso realmente não faz
muita diferença. Você pode deixá-los lá, apenas certifique-se de que este
esteja configurado como único, caso contrário,
Unity, tentaremos dividi-lo em
sprites diferentes para você Obviamente, não é isso
que eu quero para o meu jogo. Agora vamos voltar
para o meu coração aqui. Agora precisamos de um clique no tamanho nativo
definido para garantir que eles se encaixem em todo
o resto. Então, precisamos, agora
obviamente,
reduzi-los para que tenham
a mesma proporção. Vamos arrastar isso até que os pixels
tenham o mesmo tamanho. Você pode ver que
eles ainda não estão. Vamos arrastar um pouco mais. Na verdade, estamos quase lá. Vamos
aumentar um pouco até que caiba. Não precisa ser exato,
mas quanto mais perto você chegar,
melhor será
a aparência do seu jogo. Realmente não faz
diferença neste momento. Eu acho que isso é praticamente
exato. Isso deve ser bom. Vai ficar
completamente bem assim. Mas vamos mover isso para
o topo da tela. Agora podemos ver que esses
corações estarão lá enquanto eu estiver
jogando, o que é perfeito. Isso é exatamente,
na verdade, o que eu quero. Agora precisamos vincular esses corações
ao código aqui, que
basicamente define minha saúde. A maneira de fazer
isso é entrar no meu
script de saúde aqui, que está abaixo do script,
vou clicar em Player Health. Lembro-me que, logo no
início do curso, mencionei essas três
coisas na parte superior. Se você precisar usar coisas
diferentes no Unity você precisa adicionar uma linha. E é isso que
vamos fazer aqui. Vamos dizer que usando a interface de usuário do motor
Unity. Isso é só para que possamos falar
sobre coisas como imagens. Vamos ver aqui
abaixo de tudo isso,
vamos criar uma matriz
pública de sprites, em outras palavras, uma
lista de sprites,
e vamos chamá-la de e vamos Queremos que esses corações sejam de zero
a cinco. Porque haverá
seis tipos diferentes de
gastos cardíacos com a quantidade de saúde
que você tem, além disso Vamos
criar uma referência
à minha imagem e
ela não
aparecerá,
mas não digitamos UIs . Para garantir que você a tenha no topo, vamos
chamá-la de ícone de coração Agora, aqui temos nosso
ícone de coração , e temos nossos corações. Deixe-me mudar isso
para o ícone do coração. Essas duas coisas
serão capazes de
mostrar ao jogador quanta
saúde ele ainda tem. Vamos até o meu vazio aqui onde eu sofro danos E quero ter
certeza de definir meu dano, ou melhor, meu novo tipo de sprite
aqui para qualquer que seja o ícone do
coração Na verdade, vou
colocá-lo
aqui com todas as minhas outras coisas porque não quero me
preocupar em atualizá-las. Se eu estiver morto, posso simplesmente
configurá-lo para o padrão, que é o
mais baixo, obviamente. E eu realmente vou
fazer isso também. Mas antes que eu me
precipite demais, deixe-me focar em
mudar isso aqui. Eu vou dizer que, obviamente,
em uma escala de 0 a 6, eu quero definir sprite do
meu ícone de coração igual a corações, colchetes abertos. E então
teremos a saúde restante, a saúde
atual menos um, porque, obviamente, em
um raio começa em zero, se estamos com uma saúde,
você quer a primeira imagem Na verdade, esse é praticamente
todo o código real de que precisamos. A última coisa que quero fazer é embaixo do meu depósito aqui, escrever na parte inferior,
certificar-me de colocar
minha coisa Na verdade, acabei de
me ocorrer que também precisaremos
mostrar corações diferentes se não
tivermos absolutamente nenhuma saúde. Então, vamos realmente definir
isso para a saúde atual porque essa é a correta. Por um lado, queremos ter uma saúde. A segunda coisa, saúde atual aqui e zero ali. Vamos voltar à unidade. Agora, a última coisa que precisamos fazer
é, antes de tudo, criar uma referência
para aquele Heart Cycon, que vamos arrastar
para lá E em segundo lugar, na verdade
precisamos de sete elementos nessa matriz porque há seis corações
diferentes, saúde que você pode ter
e, em seguida, um com zero. Vamos voltar aos sprites
e incluir tudo isso. Temos corações, sete corações,
seis corações, cinco corações, 432.1 Na verdade, isso deve ser praticamente
tudo o que precisamos
fazer para que esse sistema funcione Se prosseguirmos e
clicarmos em play, podemos ver que temos três corações. E então, dependendo de
quanto dano sofrermos, esses corações devem cair.
Então começamos, pegamos um. Você pode ver
lá que mostramos que tem meio coração, depois outra metade. E quanto mais danos
sofrermos, obviamente, menos saúde teremos até
chegarmos a zero corações e depois nos
transformarmos nessa pequena lápide Isso é tudo o que precisamos
fazer para construir nosso sistema de saúde. Nosso jogo está realmente
funcionando perfeitamente agora. Podemos até morrer e perder. Obviamente, ainda
há alguns retoques finais que
precisamos fazer Temos que adicionar um loop de jogo. Temos que melhorar
o visual e obviamente, todas as coisas de áudio, mas na verdade isso está se
tornando uma boa parte do nosso
jogo já feita para nós Pode
parecer que ainda não está pronto,
mas, na verdade, já explicamos muitas
das mecânicas básicas E o que
sobra depois disso são muito mais adições
e coisas mais engraçadas. Construímos a maioria
dos blocos de construção. Espero que você esteja
acompanhando e tenha conseguido fazer um sistema rígido
funcionar exatamente como eu, bem
como os indicadores de saúde e de
todos os danos. No próximo episódio,
começaremos a adicionar moedas. Vamos adicionar diamantes, e cada nuvem
terá uma chance muito baixa de
aparecer em um diamante. Começaremos
no próximo episódio, mas espero que você tenha conseguido
acompanhar até agora e que seu jogo esteja se
recuperando. Obrigado.
12. 11. Apresentando gemas: Ei, bem-vindo de volta à Unity. Agora, já adicionamos o sistema de saúde de
nossos jogadores. E praticamente
tudo o mais que um
jogo de plataforma precisaria
até agora. Exceto por uma
mecânica de pontuação, moedas gemas ou algo que
você possa pegar para mostrar que está
progredindo É isso que vamos
adicionar neste episódio e vamos usar
diamantes Agora vamos começar, vamos importar nosso sprite de diamante porque
eu já fiz isso Importe diamond dong, que
obviamente está vinculado a esta
pasta do vídeo. Em seguida, ajuste esta unidade de
imagens para qualquer outra coisa e
defina o modo de filtro para apontar Agora temos um
diamante que
obviamente podemos coletar em nosso
jogo, o que é muito legal. Agora, esse diamante,
assim como os corações
adicionaram um contorno
ao redor dele apenas para deixar um pouco mais claro que
existem corações e uma mecânica de pontuação, eu poderia removê-lo
mais tarde no jogo,
mas, por enquanto, acho que ele
faz um bom trabalho ao descrever que é
diferente de descrever que é
diferente Na verdade, também vou
querer definir isso para ser uma ordem e uma camada
mais altas do que o resto do jogo, para que não fique
escondido entre as nuvens. Mas vou resolver tudo
isso em um minuto. Deixe-me começar
arrastando-o para a
tela, como acabei E isso é basicamente
uma forma abreviada de criar um objeto com
um renderizador de sprites Com esse sprite em particular, não
vou perder tempo em transformá-lo em um
pré-fabricado transformá-lo em um
pré-fabricado Então eu vou deletar
este que eu tenho
aqui e abrir
meu diamante prefab Agora, esse diamante pré-fabricado que
vamos usar,
obviamente, para codificar grande parte da lógica que queremos
para
o meu E antes de
começar a realmente escrever código, temos que decidir basicamente como o sistema vai funcionar. O sistema que
decidi fazer é fazer com cada nuvem tenha
uma certa probabilidade, podemos torná-la uma
em 31 em quatro, o que quisermos de gerar um diamante quando o jogador
pousar na E quando você pula em uma nuvem, há uma chance de
a nuvem lançar um diamante
de uma posição e você
terá que
pegar esse diamante
antes que ele caia. Acho que vou começar com ele
fotografando diretamente
para que você possa vê-lo. Mas os diamantes não farão
parte da nuvem. Eles vão pular
e depois cair. Portanto, você deve ser
capaz de agarrá-lo no ar ou
enquanto ele está caindo de volta. Mas não vai
ficar lá por muito tempo, vai pular para cima
e depois cair de volta. Então, obviamente,
não queremos ter um planador normal,
queremos ter um gatilho Então, vamos começar.
Vou adicionar um planador circular Na verdade, não é um planador só porque eu também poderia adicionar
um polígono Mas, nesse caso, ter um círculo
não é a pior coisa do
mundo, porque
você quer ser um pouco mais tolerante
com power-ups do que com caixas de sucesso Porque ninguém vai ficar chateado
por ter
coletado alguma coisa Obviamente, não
torne isso ridículo. E eu vou definir o
deslocamento para zero, certo? Deixe-me manter isso em
0,1 0,05 Vamos fazer
três. Lá vamos nós. Como eu disse,
ninguém vai ficar chateado por ter coletado
algo assim,
mas você obviamente não
quer tornar isso ridículo,
apenas faça com que seja desse tamanho E eu diria que isso
provavelmente é bom. Em seguida, certifique-se de
defini-lo como um gatilho e teremos que
criar uma nova tag. Vamos chamá-lo de diamante. Agora, antes de começarmos,
obviamente, vamos atribuir isso
antes que
eu esqueça, antes de começarmos a
adicionar toda a lógica de
como marcar e
acompanhar os
diamantes e ter
cerca de diamantes por corrida,
tudo
isso vai a lógica de
como marcar e
acompanhar os
diamantes e ter
cerca de diamantes por corrida, tudo
isso Primeiro, vamos
acabar com a lógica de realmente gerar
os diamantes quando queremos que eles apareçam, e depois podemos adicionar todas as Para fazer isso, teremos
que entrar nas
minhas nuvens e voltar
aos meus pré-fabricados aqui. E eu vou querer adicionar
a cada um desses prefabs
um script que diz,
ok, você tem tantas chances de
desovar em um diamante Vamos começar com
esse script aqui. Vou criar
um script em C sharp. Vou
chamá-lo de Diamond Spawn. Vou
clicar duas vezes para abrir isso no Visual Studio. Onde eu quero que o
script funcione é. Quero dizer que sempre que
um jogador pula em cima de mim, é quando a
chance de uma em três é calculada de se eu quero
aparecer em um Mas isso é um pouco confuso porque é muito
difícil diferenciar Ok. É a primeira vez que
os jogadores pularam até mim? Porque eu obviamente não quero que o jogador consiga pular
quantas vezes quiser e,
eventualmente, aparecer em um diamante Quero que seja decidido antes mesmo
que ele pule nele, se isso vai
gerar um diamante ou Vou usar um método um pouco estranho de codificação aqui, mas na verdade é uma
das melhores maneiras, na minha opinião, de fazer isso Vou começar
sob meu vazio original. Eu vou dizer que deixe um inteiro
x ser igual a um intervalo aleatório. Lembre-se de que
decidimos que o alcance era inclusivo no mínimo,
mas não no máximo. Acho que se você usa
floats, é inclusivo, mas com números inteiros não é E vamos definir aqui número inteiro
público e
teremos a chance, esse é aquele em
quantas chances Vou passar de um para
minha variável de chance mais um. Em outras palavras, se
eu fizer 1,2, será 1 a 3,
o que me dará um ou dois Então vou dizer que se
x é igual ao acaso, porque essa é
provavelmente a melhor maneira de codificá-lo. Obviamente, se formos iguais ao
número máximo, por exemplo, se for três, ele escolherá 1-3. E
se for igual a três, sabemos
que sempre há muitas chances de obtê-lo Praticamente tudo
realmente funciona. Você poderia dizer chance
menos um ou até 0,01, mas essa é uma boa maneira de saber se ela
estará na faixa Vamos adicionar colchetes
ao redor dessa declaração if. E então, dentro desse
código aqui, é aqui que vamos dizer o que acontece se tivermos
essa chance. Agora, na verdade,
não é isso que
queremos, queremos dizer que, se
não tivermos essa chance, se eu obtiver algo
diferente do número
que quero obter, vou querer destruir ou excluir esse script real
anexado ao meu código. Eu vou dizer
gameobject, Get component. Em outras palavras, encontre
no meu objeto de jogo algo chamado diamond spawn , que é esse script atual E, em seguida, exclua-o. Isso pode parecer um
pouco confuso, mas basicamente o que
estou fazendo é , ok, começar o jogo Escolha um número aleatório de
um a, digamos, três. E se você tiver algo
diferente de três
, destrua o script. O que isso vai fazer é
significar que, em média, apenas um em cada três
desses scripts reais permanecerá no meu objeto de jogo. Quando eu tiver o jogo, quantas nuvens
aparecerão? Há uma chance em três
de esse roteiro sobreviver. E então eu vou escrever um código abaixo disso
que diz, ok, se eu interagir com o jogador, então apareça no E também vou
excluir o script porque eles
não querem gerar mais diamantes depois que
eu Antes de me antecipar, vamos criar
mais algumas variáveis, objeto de jogo
público,
diamante, e na verdade também vou
criar uma referência a um corpo rígido Em seguida, vou prosseguir com
minha atualização vazia. Eu o excluo, vou
substituí-lo por um vazio na colisão, insira
dois D. Vou dizer se
a
tag de comparação de pontos de
objetos do jogo de colisão é Em outras palavras, se eu acabei de
colidir com o jogador. E esse código, obviamente, só será verificado se
eu atingir essa chance de 13. Se eu colidir com o jogador,
quero gerar minha coisa. Eu vou dizer que o objeto de
jogo D é instanciar diamante
como objeto de jogo Vou definir a posição do
meu novo objeto de jogo da oposição
transformada igual à minha
posição atual na nuvem que será a posição de
transformação Na verdade, talvez eu não
lance isso para aparecer exatamente na mesma
posição das nuvens Vou criar
um novo vetor. Três, vá transformar a
oposição, faça x, transforme a oposição y mais um deslocamento que eu vou
escolher agora E então a opção transformada. Estou criando um novo float, E isso vai me
permitir escolher onde, acima das nuvens,
eu quero desovar A última coisa que vou fazer é
definir RB, que é minha referência a
um corpo rígido igual a D, que é meu diamante
recém-criado Obtenha o componente de
corpo rígido dois D. Vou
adicionar um corpo rígido
ao meu diamante e é assim
que vou
fazê-lo pular no ar Vou usar Rb, a
velocidade é o novo vetor dois, defina-o como zero e
vou definir, vou criar um
novo flutuador aqui em cima, que será minha velocidade de lançamento de
diamante Então, vou
chamá-lo de lançamento. Isso vai denotar
praticamente o quão alto no ar o diamante
vai cair Então,
na verdade, vou criar um script separado em cima do meu diamante que
dirá que, se eu for ao ar com o jogador, faça isso, caso contrário,
vou querer
me deletar que atingir esse nível de
posição y. Porque a forma como
vai funcionar é que toda vez que eu pouso em uma nuvem, ela lança
um diamante. Então vai cair. Se
o jogador não acertar, não
queremos
cair para sempre. Isso vai tirar
muitos tipos de cálculos e
poder de computação do jogo, mesmo que isso nem esteja
acontecendo na tela. Então, vamos continuar e
deixar isso por enquanto. Basicamente, o que estamos
fazendo é dizer que, enquanto ainda
existirmos, quando o
jogador pousar em nós,
surgirá em um diamante Coloque sua posição um pouco acima de nós e atire
para o céu. Então, antes de realmente peitarmos, se isso funcionar, há
algumas coisas que precisamos fazer. Primeiro, precisaremos ter certeza que o player é um tag player. Então, vamos
marcá-lo como jogador, que
na verdade não tínhamos feito antes A segunda coisa
que precisamos fazer é entrar no meu pré-fabricado E eu preciso me
certificar de adicionar o script a
cada um deles. Vamos digitar
meu roteiro de poesia que
acabamos de fazer aqui. Vamos definir a chance
para 1.3 Por enquanto, vamos aos pré-fabricados
e definir nosso diamante como os corpos
rígidos pré-fabricados serão atribuídos
quando aparecermos E então vamos definir o
deslocamento para algo como 0,5 e o lançamento para
algo como cinco por enquanto Obviamente, podemos
ajustar isso mais tarde, mas certifique-se de que
obviamente está editando
cada um desses
prefabs que E, obviamente, podemos
alterá-los conforme necessário. Mas a última coisa que
precisamos fazer agora é que
isso realmente vai
funcionar muito bem. Vamos desovar
em nosso diamante. E tudo vai funcionar,
exceto o corpo rígido porque ainda não
temos um corpo rígido preso ao nosso
diamante Vamos corrigir isso adicionando dois
D.
Em um corpo rígido , isso é
praticamente tudo o
que precisamos fazer Vou congelar
a rotação Z, mesmo que isso
realmente não faça diferença. Vou me certificar de
que o colisor seja um gatilho, que
é o que eu queria Na verdade, isso é
tudo o que precisamos
fazer ao
criar nosso script. Temos esse script
aqui que vai dizer,
ok, desovar em nosso diamante Deveria ser que cada
uma em cada três nuvens geraria um diamante.
Vamos testar se isso funciona. Vamos clicar em play e
ver como avançamos. Temos uma nuvem de desova. Vamos ver se ele manteve um script.
O roteiro não está sobre isso. Acho que esse não era
o um em três. Vamos ver se há
um depois disso. Esse também
não está ligado. Aquele
claramente foi destruído. Meu Deus, isso é difícil.
Você pode ver ali, essa era a única chance
em três em que
pudemos ver o diamante gerado Agora, o problema é que na verdade
não
destruímos o script, então isso vai
acontecer toda vez. Mas eu acho que
parece muito legal. Na verdade, funciona muito bem, e temos um
diamante surgindo. Eu quero fazer alguns ajustes. Em primeiro lugar, quero mudar
essa velocidade de lançamento
para algo como 6,8, para que
tenhamos uma chance um pouco melhor de
desova Vai ser um pouco mais fácil pegar aquele diamante
à
medida que ele sobe. Na verdade, vou fazer algo mais parecido com
oito, na verdade, e ver se isso é
um pouco ridículo, mas pode funcionar muito bem Deixe-me testar isso, obviamente. E então, obviamente, no
meu jogador,
eu também quero
diminuir a velocidade
dele e aumentar a
altura do salto. Na verdade, eu poderia até aumentar um
pouco a escala de gravidade. Esses são apenas
alguns ajustes que estou fazendo. Então, eu estou mudando
minha escala de gravidade, vou torná-la 2,5 ,
vou fazer a altura do
salto 12 e vou
fazer a velocidade cinco. E vamos ver como esse
jogo funciona,
porque parece um pouco
flutuante no momento. Na verdade, isso é muito
melhor do que eu esperava. Isso é muito melhor e
muito mais parecido com o que
eu quero que você veja agora. É muito mais fácil
pegar esses diamantes. Obviamente, eles ainda estão
desovando infinitamente, mas isso deve ser bom por enquanto Então, vamos criar rapidamente aquele
tweet que precisamos fazer. No minuto em que
geramos um diamante, obviamente queremos excluir nosso script porque não
queremos gerar vários Então, vamos copiar isso. E então tudo o que precisamos fazer
depois disso é adicionar um script ao
próprio diamante que diz que se eu
colidir com o jogador, aumente essa
variável no jogador E eu vou ter um
novo roteiro aqui. Eu vou ter
dois novos roteiros. Um deles
será adicionado ao jogador, que acompanhará quantos diamantes
o E um deles
será adicionado aos diamantes que
acompanham quando o jogador
colide com o Vamos
criar um script em C sharp, chamado de player diamonds Na verdade, isso não será um
bom script,
será apenas um número inteiro, que dirá
public int diamonds Na verdade, também
teremos um público com diamantes de alta pontuação Haverá o
diamante, a
corrida atual e haverá nossa escola secundária. Falaremos sobre isso
mais tarde, mas esses são os únicos de que precisamos por enquanto. Então, tudo o que vamos
fazer depois disso é criar
um novo script também. Aqui, vou criar
um script de loja e chamá-lo diamante no script. Tudo o que vou ter é um único evento vazio no
gatilho, digite dois D, se o objeto do jogo de colisão
comparar o tag player, então vamos colidir com a
coisa com a qual eu colidi para encontrar um componente
chamado diamantes Vamos colocar colchetes aqui para que
possamos colocar tudo dentro declaração e encontrar
uma variável
chamada diamantes
e incrementada em colchetes aqui para que
possamos colocar tudo dentro
da declaração e encontrar
uma variável
chamada diamantes
e incrementada em um. Em outras palavras, se
eu colidir com o
jogador, aumenta os diamantes em um. E então precisamos realmente
excluir a instância
desse prefab Então, vamos
destruir o objeto do jogo, que basicamente
excluirá esse diamante atual. Então, a última coisa que
vamos fazer é adicionar uma condição se colidirmos com a
parte inferior do mapa. Na verdade, também queremos
fazer exatamente a mesma coisa, me
destruir e não
incrementá-la desta Para fazer isso, vamos
adicionar
um colisor na parte inferior
da câmera principal, porque é aí que a
jogabilidade acontecerá E vamos adicionar
um colisor de bordas dois D, vamos
vê-lo ali Isso é
o que será usado
basicamente para rastrear se chegamos ao final
do mapa ou não. Vou mover o deslocamento do Y para cerca de lá Podemos ficar um
pouco embaixo da tela, realmente
não
faz diferença. Então, vamos definir os
pontos para menos cinco, ou melhor, menos
dez, talvez até. Na verdade, queremos ser
maiores do que a tela. Digamos menos 12,12 Agora, isso também será um colisor de
gatilhos Então, vamos
ter uma pequena linha de código aqui que diz else if collision game
object dot compare tag Se eu bater na câmera principal
, ainda quero excluir
a instância desse prefab Na verdade, isso deve funcionar muito bem se colidirmos
com o jogador Queremos excluir
o objeto do jogo, mas também adicioná-lo ao inventário do
jogador. Se colidirmos com
a câmera principal, também
queremos
deixar de existir Vamos ver se isso funciona.
Primeiro, vou tentar não adicionar nenhum diamante. Antes de realmente
testar isso,
obviamente preciso adicionar o script de diamante
do meu jogador, que esqueci de fazer, e acompanhar quantos
diamantes Na verdade, também esqueci adicionar a
escrita de diamante ao diamante Vamos aqui e adicionar a escrita
de diamante. E eu acho que isso é tudo. Porque o spawn
de diamantes que já adicionamos. Vamos clicar em play e testar exatamente
se isso funciona ou não. Teremos que testar
para ver se os diamantes aparecem
ou se nenhum diamante apareceu ainda ou se nenhum diamante apareceu Teremos que
acompanhar a câmera, obviamente, para ver se vamos
perder uma lá. Diamond apareceu. Parece que diz que a tag
da câmera principal não está definida. Oh, nós escrevemos errado. Essa é uma solução muito fácil.
Vamos remover esse espaço
e testá-lo novamente, porque atualmente estamos
recebendo erros que dizem: ok, eu não sei o que é a câmera
principal,
mas é apenas a câmera principal. Uma palavra. Vamos tentar isso de novo. Deve funcionar agora. Não, esse jogo é
preocupantemente difícil, mas eu chego lá em Obviamente, os ajustes
do jogo geralmente
vêm da dificuldade com que você cria esses músculos
que você criou Vou trapacear um pouco e devolver minha saúde ao Max
porque estou prestes a morrer Vamos definir a saúde atual para seis. É uma das coisas legais
de desenvolver o jogo. Isso também é impossível,
o que eu preciso corrigir como está. Lá vamos nós. Lá
temos um diamante, e parece que ele apareceu
, o que é ótimo Vamos reduzir minha saúde
para dez desta vez. Vamos
cometer alguns erros porque,
na verdade, não pretendemos ter saúde
acima de dez. Mas está tudo bem. Isso não vai
quebrar o jogo. Vou tentar coletar um diamante e parecia que
funcionou perfeitamente bem.
Eu coleciono um diamante. Se formos até meu jogador, podemos ver que tenho
diamantes como Quase tudo realmente funcionou muito, muito bem. Agora, tudo o que precisamos fazer
é adicionar um contador para que possamos saber quantos
diamantes coletamos Vamos ver minha interface de usuário
aqui na parte superior, abaixo dos corações, vamos querer criar uma nova imagem Vou copiar isso por enquanto e movê-lo um pouco para baixo. Eu vou querer que essa
imagem seja um diamante. Vou definir o tamanho nativo
definido. vou precisar Obviamente, vou precisar reduzi-lo, assim como fiz
com o outro, para garantir que os
pixels tenham o mesmo tamanho
, sejam um pouco maiores. Veja, isso parece
muito bom para mim. Obviamente, como eu disse, não precisa ser perfeitamente exato, mas precisa
ser bastante preciso. Se você quer que um jogo tenha uma boa aparência
, tudo o que precisamos fazer, na verdade, é mover isso. Em vez de ter
diretamente abaixo, vou colocar isso
do outro lado, assim. Agora vou ter a
pontuação à esquerda, o que pode parecer um pouco
estranho para algumas pessoas, mas você pode escolher
o que quiser fazer Na verdade, posso
mudar isso mais tarde,
mas, por enquanto, acho que
funcionará muito bem. Vamos mover isso
para baixo, está alinhado, então vamos realmente
chamar isso de diamante. Então, tudo o que precisamos fazer
é acessar minha interface de usuário e criar
outra interface de usuário de objeto, chamá-la de texto, e você precisa criar um profissional de malha de texto. Você
vai ver esse pop-up. Basta clicar em Importar e
ele importará todos
os arquivos necessários para
esse pacote específico. Você realmente não
precisa dos exemplos em extras, então não
vou importar isso. Então vou pegar
minha nova caixa de texto e colocá-la como um objeto
infantil desse Vou
arrastá-lo para baixo, assim como fizemos
logo no início
do
jogo com armazenamento Vou ajustar a
posição X para ser algo como -100 posição Y para ser zero Está no meio.
Vou apenas ajustar o resto
desta caixa como achar melhor. Acho que isso provavelmente é bom. Mova-o para cima e para baixo então. Só vou me certificar de que
tenho o bom senso aqui. Eu quero que esteja alinhado corretamente. Acho que com o pino ativado, vou manter o ph agora
porque não consigo imaginar nenhuma instância em que
você usaria tudo. Você teria que coletar
muitos diamantes. Mas só por segurança,
vou movê-lo dessa forma e na verdade,
vou desabilitar o
empacotamento Não faz isso.
Pronto, muito melhor. Agora ele se estenderá o mais longe
possível, acima do outro lado. Então eu vou
querer ter que escolher quanto disso eu
obviamente quero exibir. Vamos testar em um valor padrão de 540 que
não parece muito bom Obviamente, você terá que
escolher uma fonte diferente e
tudo mais. Vamos ver, temos
uma fonte de sombra projetada. Não parece ótimo. Uma fonte
de contorno pode parecer boa. Você realmente não pode ver
isso, pois não há uma quantidade incrível de fontes disponíveis para você apenas
incorporadas ao Unity, é por isso que eu
incluí outra fonte que é a mesma fonte que vou usar, que encontrei
na Internet. Você pode encontrar um
monte de fontes
gratuitamente em vários sites. Certifique-se de que eles tenham
a licença correta. Mas se você encontrar
uma dessas fontes, poderá encontrar uma
fonte que se encaixe muito bem no
seu estilo de jogo.
Eu vou usar esse. Vamos prosseguir com os diversos
e clicar
em Novo e clicar Aqui está, Bloopf. Temos um tamanho de fonte aqui. Eu não mexeria muito com
eles. Podemos testá-las depois
de adicionar a fonte, mas deixá-las como estão. Agora, para usar uma fonte extra, na verdade não
podemos usar
essa prosa de malha de texto Teremos que
excluir isso e criar uma nova interface de usuário. Só vamos
querer uma mensagem normal. Eu tenho que ir em
Legado e clicar em Texto. Vamos dar um nome a esse contador. Então eu vou arrastar
exatamente como fiz da última vez. Vou configurar o transbordamento horizontal para
transbordar. E eu vou colocá-lo
alinhado corretamente. Mova-o dessa maneira. Eu quero que seja
centralizado no meio. Eu quero que seja letra
maiúscula, você vê aí. Parece que está tudo bem. Mas está
muito embaçado. E da maneira como
corrigimos isso, vamos aumentar o tamanho da fonte, mover a coisa para o
maior tamanho possível. Você pode fazer com que seja
no máximo 300. E eu acho que isso geralmente
é o que você precisa fazer para que o pixel seja renderizado, então você só
precisa reduzir a escala
até o fim. Vamos reduzir isso. Vamos clicar neles e escalar proporcionalmente
até o que queremos. Acho que precisamos de um
pouco menos do que isso. Na verdade, vamos tentar um
0,12. Isso pode ser bom. Vamos tentar mudar a cor para o que realmente queremos que seja, que é branco. Está alinhado ao centro, mas não
parece estar no centro Então, vou
configurá-lo como alinhado na parte inferior. E vamos tentar 150.
Parece que está tudo bem. Talvez eu não seja sua fonte
favorita, mas é a que
vou usar para
esta demonstração. Obviamente, você pode encontrar uma fonte
diferente on-line
se quiser, mas acho que, por enquanto, ela
realmente funciona muito bem. Vamos torná-lo um
pouco mais escuro, para que não seja branco brilhante, mas isso deve funcionar como nossa fonte básica para controlar
quantas gemas temos Agora, obviamente, só precisamos
escrever o código que diz, ok, exiba o número
certo aqui. E tudo isso será feito dentro do
script de diamante do nosso player aqui. Vamos criar uma
referência para Eyes in Unity. Vamos tornar público o texto de atualização
anulado. E dentro dele, acima disso,
na verdade, vamos criar uma referência ao nosso contador. Vamos dizer que o contra-texto igual a diamantes, duas cordas Em outras palavras,
defina a variável de texto, que é o que estamos escrevendo
nesta pequena caixa aqui. Quando clicamos nisso, o que essa pequena caixa tem dentro
dela, que
define o valor atual dos dela, que
define meus
diamantes como uma string,
é armazenado como um é armazenado como Temos que
convertê-lo para o formato de texto. Antes de fazermos isso, obviamente
chamaremos esse texto de atualização de nulo
toda vez que incrementarmos Vamos colidir, pegar diamantes
componentes, Na verdade, isso deve
funcionar muito bem. Tudo o que precisamos fazer é voltar para o Unity e garantir que também
atribuímos essas
duas variáveis. Vamos até o balcão
aqui e arraste-o para dentro. Vamos começar com
um valor zero, para não começarmos com
uma quantidade aleatória de diamantes e ver se
isso realmente funciona Se clicarmos em jogar, agora temos nosso contador de diamantes
à direita Temos nossos
corações à esquerda. Vamos ver se podemos coletar
e tornar esse jogo mais fácil. Vamos ver se podemos
coletar diamantes. Na verdade, posso
até aumentar um pouco mais a altura do
salto. Eu vou fazer isso a partir de 12, vou fazer com que seja 14. Vamos ver se isso
funciona um pouco melhor. Pode ser um pouco alto. Vamos mantê-lo em 12, mas talvez aumente um pouco a
velocidade. Vamos fazer com que a velocidade seja seis. Eu sei que originalmente eram seis, mas acho que na verdade
funcionou um pouco melhor. Sim, isso é um pouco
mais fácil de atravessar. Isso deve ser bom.
Obviamente, só precisamos esperar por um spawn escuro para ver se podemos testar nossa coleção de diamantes Eu não acho que teria
comprado esse de qualquer maneira. Não, não há diamante lá. Tem um. Lá
vamos nós. E você pode ver que funciona
muito, muito bem. Agora temos um diamante
e o coletamos, e espero que esteja lá Há dois diamantes.
Essa é basicamente a base do nosso sistema de coleta de
diamantes. Obviamente,
vamos começar com os
retoques finais do nosso jogo Mas temos todos os fundamentos básicos
antes de podermos construí-lo. Temos que adicionar
pós-processamento, fazer com que pareça muito melhor, áudio e música e
tudo mais. E também precisamos
economizar para garantir
que economizemos
quantos diamantes temos Mas acho que
chegamos muito longe até
agora e, na verdade,
fizemos uma boa
parte do jogo, se você
acompanhou e seu jogo é, na verdade,
como o meu é agora, um bom trabalho porque você já tem
praticamente um jogo de plataforma. Como tudo o mais que
vamos adicionar agora, vai
torná-lo muito melhor. Mas esses são todos os princípios básicos. Temos inimigos,
temos um sistema de saúde, temos minha mecânica e também temos uma contagem de quantos diamantes Tudo está
funcionando exatamente como precisávamos. No próximo vídeo,
adicionaremos um loop
de jogo para que
possamos
jogar o jogo continuamente sem precisar clicar e clicar
para reiniciar Mas depois de fazermos isso,
você praticamente
terminará o jogo, todos os seus componentes básicos,
de forma alguma terminará o jogo. Porque você ainda precisará adicionar
a música e todas as outras
coisas de pós-processamento para melhorar a aparência Mas você vai terminar a base do jogo, é
o que eu deveria dizer. De qualquer forma, isso está tudo
no próximo vídeo. E se você acompanhar
até agora, ótimo trabalho. Obrigada.
13. 12. Criando um loop de jogo: Olá, e bem-vindo de
volta à Unity. Há mais uma
coisa que precisamos
acrescentar para que este jogo
seja
praticamente o básico de um jogo que devemos ser capazes de jogar.
E isso é um loop de jogo. Em outras palavras,
podemos continuar jogando o jogo pelo tempo que quisermos, porque agora, se
pularmos do mapa ou morrermos, se algo acontecer, pronto. Realmente não temos mais
nada acontecendo. E nem podemos realmente morrer dessa forma. Essa é a primeira
coisa que precisamos corrigir. Mas, obviamente, não podemos
continuar jogando, o que é o primeiro problema. Vamos adicionar a mecânica que
diz que se tocarmos na parte de trás
da tela ou cairmos
na parte inferior, morreremos Vamos começar
movendo isso um
pouco para cima aqui para deixá-lo praticamente
na parte inferior da tela. Obviamente, se você tocar
nisso, não
conseguirá se levantar
da mesma forma que pode voar de volta. Isso é bom. Na verdade, vamos adicionar outro colisor de bordas desta vez. Vamos adicioná-lo às laterais
das telas. Vou clicar em
Editar Collider. E eu vou
arrastar aquele até lá. Acho que,
na verdade, está um pouco perto demais. Vou arrastá-lo
logo atrás da tela. E o segundo eu
vou arrastar até aqui. E então vou
ajustá-los para que a
mesma distância seja igual a
-10,8 para ambos Vou fazer com que o elemento y seja
cinco e menos cinco. Na verdade, isso deve ser
praticamente tudo o que precisamos. Tudo o que precisamos fazer
agora é
adicionar um script na minha câmera principal, no
meu
player, que diz que se eu tocar na câmera principal,
eu também tenho que morrer. Vamos voltar aos scripts. Abra a saúde do jogador
aqui embaixo do meu gatilho,
fique três. O que
vou dizer se eu colidir
com um inimigo e tempo de
invisibilidade for
esse, então faça Caso contrário, se não for inimigo, se eu colidir com
a câmera principal, seja, com os
limites do mapa
, não importa
quanto tempo resta de invisibilidade Qualquer outra coisa assim,
eu preciso morrer instantaneamente. Em vez de chamar
o take damage de vazio, vou
apenas causar uma certa quantidade de
dano e verificar se estou
morto e, se estou morto,
depois chamo a morte de vazio Caso contrário, chame
que há um vazio morto. Eu mesmo vou chamar
o Death Void e dizer,
ok, então eu
obviamente preciso morrer e o
jogo precisa parar Na verdade, esse é
praticamente todo o código de que precisamos para garantir que seja
um recurso adicional. Agora, há mais uma coisa que precisamos realmente lembrar de fazer. Esqueci de fazer
esses dois gatilhos, que ou melhor,
este é um gatilho, aquele inferior gatilho, mas
esse também deveria ser Vamos fazer um
teste se isso funcionar. Se estivermos
correndo e pularmos contra
a parede,
morreremos instantaneamente. Podemos ver que realmente
voamos até lá. que destaca outra
coisa que
achei que poderia ser
um problema, porque me lembro de
tê-la visto uma ou duas vezes, mas eu não tinha certeza de por que a lápide subiu
mais alto do que deveria Na verdade,
isso torna tudo muito mais claro. O que está acontecendo é que, como esse é um evento de permanência desencadeadora, estamos chamando a morte de
vazio várias vezes Na verdade, vou ter que me
certificar de que só
chamaremos a morte de nula,
desde que não estejamos mortos Se minha saúde atual estiver ótima
e zero, eu não estou morto. Em outras palavras, eu não posso morrer
duas vezes. Eu só posso morrer uma vez. Porque o que está acontecendo aqui é que toda vez que morremos, fazendo tudo
isso de novo. E é como se eu
subisse um pouco, o que na verdade explica
por que às vezes eu morria, parecia que eu
também subia. Estou feliz que tenhamos explicado isso do jeito que eu
queria saber o que era. Temos que adicionar isso e não a cláusula de morte
aqui que diz, ok, só me mate se
eu ainda não estiver morto Preciso acrescentar exatamente a mesma
coisa que aqui está morto. Vamos apenas garantir que
isso esteja aqui e aqui. Em outras palavras, não podemos chamar a cláusula de morte se
já chamamos a
cláusula de morte uma vez antes Esses são os únicos dois lugares em todo
o roteiro em que
eu chamei a cláusula de morte Tudo deve
estar bem. Vamos voltar e ver se funciona agora. Deveria dar um salto até lá. Você pode ver que eu morro instantaneamente, o que é perfeitamente o que eu
quero. E também deve funcionar. Se eu cair do
fundo do mapa, também
morrerei,
o que é ótimo. Está tudo
resolvido conforme eu precisava. Agora, obviamente, preciso
adicionar meu loop de jogo, porque agora eu
simplesmente morro e
não há como jogar
o jogo novamente. Vou adicionar um pouco de código aqui que dirá
que quando eu morrer, pare por um minuto e depois
ficará preto E então vai
desaparecer do preto, tendo surgido em um
novo tipo de cena E do jeito que eu realmente
vou fazer isso, eu vou realmente
reiniciar a cena em si. Então, em vez de tentar reiniciar tudo
como era antes, em vez de tentar reativar todos esses scripts
e colocá-los de volta, vou apenas
recarregar a cena, o que é efetivamente o mesmo clicar nesse botão novamente, continuar assim e
depois ficar tudo bem, fazer de novo O que na verdade
vai funcionar muito, muito bem para mim, porque
terei uma tela preta
desbotada Eu deveria ser capaz de
carregá-lo novamente e depois fazê-lo. E, na verdade, também vai
ser bom porque não precisarei
codificar nenhuma
das coisas extras
para voltar
ao estado em das coisas extras
para voltar
ao que eu quero
estar, que é esse. Então, vou criar
um novo objeto em D. Vou criar um quadrado e vou chamá-lo de cortina
porque
na verdade não é uma cortina porque
na verdade não é uma cortina Vai funcionar
como uma cortina. Vou torná-lo maior do que todo o
meu jogo sobre esse tamanho. Deixe-me diminuir esse alfa
para que eu possa ver onde ele está. Diga que isso é quase bom. E
, obviamente, com um deslocamento zero , eu vou
aumentar o Alpa Eu vou torná-lo
completamente preto. Vou fazer com que
seja ordenado e colocado em
100 camadas para que fique na frente de
absolutamente tudo. Essa cortina. Eu não vou ter existido na grande
maioria do jogo. Mas então, no minuto em
que eu quiser, eu vou
gerá-lo e ele vai ficar preto, e então ele vai existir Então, no minuto em que eu começar,
vou querer passar do preto para o transparente e
depois me desativar. Eu vou fazer tudo
isso usando animações. Primeiro, vou
criar um novo script. Vou
chamá-lo de Curtain Script. Antes de eu realmente
codificar. Neste momento, vou adicioná-lo aos
meus objetos de cortina Eu vou aqui
e vou adicionar um script de
cortina ao meu objeto de
cortina. Assim. Então, uma vez que
eu tenha feito isso, vou abrir roteiro da
cortina e vou
criar um novo vazio público Chame isso de desativar. Isso só vai dizer que o conjunto de
objetos do jogo está ativo, falso. Em outras palavras, pare de existir. Teremos que habilitar esse objeto novamente a
partir de outro script. O que, na verdade
, será bom para nossos propósitos, porque nesse script de morte
vamos reativar o objeto e
chamar um vazio específico Estamos dizendo ok, fade to
black, não fade from black. Mas agora
precisamos desse vazio
aqui que diz,
ok, pare de existir Vou usar isso
na animação para dizer, ok, sim, está tudo bem. Então eu vou ter
um novo vazio aqui e chamá-lo de fade two Dentro desse vazio estará
onde estará todo o meu código de
animação Vou ser animador público, fazer isso e vou dizer que um set bool fade out e
vou transformá-lo O que isso vai
fazer é ter um touro que
me permita controlar, ok, eu preciso desaparecer de vez
em quando, eu vou fazer o resto usando esses
eventos no animador Mas eu preciso de mais um
vazio e
será o vazio para recarregar a cena E da maneira como
vamos codificar isso, vamos até o topo daqui
e vamos
usar o Unity Engine, Scene Manager ou o Scene
Management. Em vez disso,
esse código vai dizer gerenciador de cena , carregar
cena,
abrir parênteses, gerenciador de cena,
obter o nome da cena ativa O que isso vai fazer
é basicamente carregar qualquer que seja o nome
da cena ativa que eu tenho, que é minha única cena. Se eu voltar para o Unity, tenho uma cena de Sable Vamos renomear isso porque
esse não é o melhor nome. Vou
chamá-la de cena principal porque é a única cena que vamos usar para este jogo. Vamos construir
tudo dentro dela. E vamos ter esse
código aqui que diz,
ok, quando esse vazio for chamado,
que será chamado pelo uso da animação em um evento, desative-me Então, quando esse código
for chamado aqui, fade two, que
será chamado pelo script de saúde do
jogador Vou definir meu fade out como verdadeiro e vou desvanecer E então, no minuto em
que esse código, que também será
chamado pela animação, eu vou recarregar
a cena por completo e ela vai começar
exatamente onde eu quero estar Vamos voltar ao
Unity e criar uma nova animação. Claro,
vamos precisar de dois. A primeira animação será chamada Curtain Fade In E, obviamente, queremos passar
do preto total para o nada. E vamos
adicionar um buffer aqui. Isso vai mexer
com a animação, mas vamos definir isso
para zero ali E então certifique-se de que também
temos o conjunto 20. Agora eu tenho um fade in
e depois ele fica aqui. E a razão pela qual estou
adicionando isso é porque vou adicionar um
evento aqui Às vezes, você adiciona um evento
logo no final de um quadro. Isso causa alguns
problemas porque, na verdade,
não existe
nesse quadro por muito tempo. Se tecnicamente não
convocar o evento, às vezes vai até o
início sem ligar, depois se repetirá duas vezes
para salvar tudo isso Vou dedicar bastante
tempo para convocar esse evento E confie em mim, um terço de
segundo é mais do que suficiente. Vou usar o script de cortina e vou dizer desativar Depois que eu entrar, ele se
desativará sozinho. Vamos garantir que,
se abrirmos a cortina, essa seja a
coisa padrão, porque isso que eu
quero que aconteça primeiro No minuto em que eu começar o jogo,
ele vai fazer isso. Em seguida, vou
criar um novo script. Chame isso de cortina desvanecer-se. Esse script, ou melhor,
essa animação, desculpe, só será
chamado enquanto um parâmetro do tipo
fade out for verdadeiro Acho que é assim que chamamos
se voltássemos aqui. Sim, chamamos isso de fade out. Somente quando fade out é verdade. Não vamos usar
nenhum estado aqui porque essa é a máquina de estados
mais simples do mundo. Mas vamos
definir o tempo de folga X, vamos definir a duração da
transição para zero. Vamos definir
as condições para ser. Fade out é igual a true,
então, enquanto fader for true, chamaremos essa animação
de fade Isso vai dizer,
ok, do nada, vamos
querer ficar pretos Então, o que estamos fazendo
aqui depois disso, depois de ficarmos pretos, queremos
convocar um novo evento Vamos fazer
exatamente a mesma coisa aqui. Vamos adicionar um buffer
aqui em 1 segundo. Vamos chamar
esse novo evento
que será cena de recarga Agora, isso é
praticamente tudo o que precisamos fazer, porque
agora
temos todo o código para
desaparecer no minuto em que
começamos ou desaparecer , em
vez de no minuto em
que começamos a cena e desaparecemos Mas ainda precisamos de algo
para chamar esses scripts. Em outras palavras, no minuto em
que morremos depois de esperar talvez um ou dois segundos,
queremos chamar esse script. Vamos ver o script de
saúde do meu jogador aqui. Vamos primeiro criar
um novo numerador I. Chame isso de recarregar, Delay.
Vai ser muito simples. Vamos apenas
dizer rendimento, retorno, esperar por segundos e
vamos esperar por 2 segundos. Então, vamos
querer fazer duas coisas. Primeiro de tudo,
vamos querer
ativar a cortina de
objetos do jogo Vamos criar uma referência
para isso. Vamos usar um objeto de jogo
público,
chame-o de cortina Vamos ativar o conjunto de
cortinas. Em outras palavras,
ative a cortina novamente. Então vamos querer chamar isso
de fade to void. Imediatamente
vamos cortar, pegar componente,
cortina, script, fade Acho que é assim que
o vazio é chamado. Sim, fade two. Em outras palavras, quando
morrermos, espere 2 segundos. Ative a cortina e faça com que ele desapareça. Ou
faça com que desapareça. Tudo o que precisamos fazer aqui
no final da morte é anular esse atraso de recarga Acho que isso deve ser tudo o que precisamos
para trabalhar, obviamente. Vamos verificar isso porque
geralmente há bugs quando
estamos fazendo isso. Mas vamos garantir que
tudo esteja como precisamos. Obviamente, só mudamos esse roteiro da
cortina por aqui. E olha, não
ativamos o animador, mas fora isso, acho que
tudo deve ficar bem Oh, quase esquecemos de
realmente atribuir as cortinas. Vamos aqui para jogar nossa
saúde e garantir que tenhamos colocado cortina corretamente.
Vamos ver se isso funciona. Se pudéssemos jogar,
pudéssemos ver como quisermos, o que é ótimo se morrermos. Vamos tentar lá. Esperamos 2 segundos, o que pode ser um pouco longo. Então, podemos ver que a cortina não parece estar realmente
sendo ativada Talvez tenha algum problema aqui. Vamos voltar
e dar uma olhada no nosso código. Quanto tempo esperamos por 2 segundos e colocamos a
cortina ativa como verdadeira Vamos garantir que esse atraso de
recarga esteja sendo chamado definindo uma
instrução de impressão aqui Foi assim que você
conseguiu testar isso. A coisa não é como você tem que fazer, é
assim que eu gosto de
fazer. Vamos tentar novamente. E podemos ver que a declaração impressa
claramente não está funcionando. Portanto, essa corotina
não está sendo chamada. E é porque não
escrevemos start corotine. Veja, é uma coisa delicada. Às vezes eu esquecia naquela época. Mas vamos escrever Start Corotine, reload delay e espero que tudo funcione Agora vamos voltar ao meu jogo. Então clique em play e
veja se funcionamos. Quando morremos, caímos. Lá vamos nós. Agora
temos que esperar 2 segundos. Vamos desaparecer e voltaremos ao Na verdade, isso está
funcionando muito bem. A última coisa é que, obviamente,
o fade in não está realmente fazendo efeito
porque está
acontecendo apenas na
localização específica da tela, o que não é o que queremos que seja exatamente onde está
a câmera principal Só vou escrever mais um
pequeno trecho de código. Em primeiro lugar, vamos
tornar a cortina um pouco maior porque a
câmera começa se movendo Na verdade, isso
vai mudar quando adicionarmos nosso hub inicial. Mas, por enquanto, vamos torná-lo um pouco maior apenas para
garantir a segurança. Vamos aumentar um pouco essa escala
, só para que ainda não
desapareçamos dela Então, por último,
vamos dizer que a posição de
transformação do é
igual ao objeto do jogo
Encontre em nossa cena, encontre uma câmera principal. A posição da
câmera principal é onde eu quero estar. Vamos ver se isso funciona.
Deve funcionar perfeitamente bem. Agora apertamos o botão play. Podemos ver que temos um fade
perfeito na animação funcionando perfeitamente se
morrermos esperando por 2 segundos, que pode ser um
pouco longo, mas
vejo que parece que não está Acho que o
problema é que pode estar mudando a
posição Z. É meticuloso. Coisas assim
na maioria das vezes. Vamos jogar o objeto do jogo para
encontrar a posição principal da câmera. E então vamos nos
certificar de que realmente mudamos essa posição para
zero no eixo z, e isso pode realmente
resolver nosso problema. Vamos ver se isso
acontece. Lá vamos nós. É sempre estranho,
coisas assim. A câmera principal está
um pouco atrás da cena, por isso nos deu uma
aparência um pouco problemática Mas isso é tudo o
que precisamos fazer. Garantimos que a
posição seja a mesma. Agora podemos jogar o
jogo infinitamente. Temos o que é
chamado de loop de jogo, o que é muito, muito legal, porque essa é a base que
precisamos para o nosso jogo. Fizemos tudo o que precisamos agora, exceto todas as coisas extras como áudio, música
e tudo mais. Vamos excluir o script de teste
que colocamos
aqui , que era a
impressão daquele. Obviamente,
mudamos a posição agora que ela redefine
a posição zero Mas todo o resto
deve ficar bem. Na verdade, agora
não temos apenas um jogo, essa animação está desaparecendo
para fazer com que o jogo pareça um pouco mais, eu
acho, profissional Então essa é a base
desse episódio,
concluído, bem como
a base do nosso jogo. Praticamente pronto,
o que é muito legal. No próximo vídeo,
começaremos a economizar, que
possamos economizar quantos
diamantes realmente guardamos E temos uma
escola secundária, que continua mesmo depois de
sairmos do jogo, para que não percamos nosso
progresso todas as vezes. Mas isso é praticamente
tudo neste vídeo. E se você
acompanhou e tudo está funcionando exatamente como o meu, isso
é ótimo. E espero que seu loop de jogo
esteja funcionando exatamente assim. E você conseguiu
construir praticamente toda
a base de
uma plataforma, um jogo. Parabéns por
ter chegado até aqui. E se tudo
estiver funcionando
como o meu, isso é
ótimo. Obrigada.
14. 13. Salvando nosso jogo: Olá, e bem-vindo de
volta à Unity. Agora, esse provavelmente
será o episódio mais curto de todo
o curso, porque
tudo o que vamos
acrescentar nesse episódio é economizar Isso pode
parecer muito complicado. Na verdade, se usarmos certos
métodos de economia, isso seria muito mais difícil do que o que
vamos fazer. Mas vamos usar a forma mais simples e básica que
o Unity permite que você salve
em seu motor de jogo, chamado Player Prefs Agora, apenas como um aviso, se você planeja
lançar este jogo talvez especialmente se for
um jogo multijogador ou
algo parecido um jogo multijogador ou
algo Quer dizer, eu não
sei exatamente como você vai pular dessa plataforma
para um jogo multijogador. Mas você sabe, se você usar
isso como um trampolim para iniciar o desenvolvimento de jogos e planeja lançar uma
versão adequada e
comercialmente viável,
provavelmente terá que escolher salvar seus jogos de uma
maneira Porque a maneira como vou
salvar meus jogos é salvando
arquivos específicos no computador. E eu meio que os
estou salvando de não é a mais
criptografada ou,
acho, difícil de forma que
não é a mais
criptografada ou,
acho, difícil de decifrar. Então, se eu salvasse meu jogo
inteiro
assim, não precisaria
de muita dificuldade para alguém editar esses arquivos e dar a si mesmo um monte de
habilidades ou moedas extras. Agora, esse não é o maior
problema porque, quero dizer, se alguém realmente
quer fazer isso em um jogo para um jogador, meio
que E, de qualquer forma, poucas
pessoas que jogam videogame acabam adulterando
os arquivos Mas se você planeja criar algo como um jogo
multijogador, obviamente
é uma coisa
incrivelmente ruim de se ter. Como você não pode deixar que
alguns jogadores
consigam se dar um
monte de coisas e outros jogadores não, de qualquer maneira, com esse aviso
esclarecido, economizar na maioria das plataformas
independentes básicas será
muito bom, na Algumas pessoas podem discordar, mas é muito fácil de
manipular. Mas isso não é realmente um problema
para jogos independentes como esse, porque a diversão é
determinada pelo jogador
e, se ele quiser
estragar tudo, Mas acho que isso vale
para qualquer jogo em geral. Vamos começar com
o script de salvamento porque não vai
demorar muito. Tudo o que precisamos fazer é
ir até
aqui e ver nossa
escrita de diamante aqui. Não é uma escrita de diamante. Vou tocar uma escrita de diamante aqui. Vou
clicar duas vezes nisso. E vamos
ter um novo vazio. Vou chamar isso de vazio público. Guarde diamantes dentro deste bloco, contorne a declaração
if para dizer se os diamantes são maiores
do que os diamantes do ensino médio Em outras palavras, se terminamos
o ensino médio
, queremos usar as preferências dos jogadores
incrustadas em diamantes, queremos defini-las Essa pequena linha de código aqui
basicamente vai dizer,
ok, pegue o que
eu quiser inserir,
que é minha variável diamonds, que é minha variável diamonds, e coloque nesse número inteiro no Playerprefs chamado diamonds,
que basicamente significa salve-o
em que Se eu quiser comprar isso
mais tarde, posso usar Playerprefs e colocar Na verdade, vou
fazer isso logo
no topo daqui,
no meu vazio inicial Eu vou dizer início vazio. E eu vou dizer que diamantes do
ensino médio são iguais a
Playerprefs entram em diamantes Playerprefs Na verdade, isso só vai funcionar depois de
jogarmos o jogo pelo menos uma vez, porque até
lá não teremos nenhum valor aqui. Então, vamos adicionar uma declaração
rápida se se jogador preferir ter diamantes-chave,
em outras palavras, se
já salvamos algo dentro dessa
coisa de diamantes, Obviamente, esse código não será executado na primeira vez
que jogarmos o jogo. Os diamantes do ensino médio serão
reduzidos a zero. Na verdade, podemos definir
esse valor
ali como um valor padrão, o que também é uma boa
convenção de programação. Porque o Unity define todos
esses valores por padrão como zero porque os
atribuímos no ar. Mas se você estiver usando
um mecanismo diferente ou uma
linguagem de programação diferente, talvez não. Então, vamos seguir
em frente e fazer isso. E então, digamos que seja um vazio inicial. Se tivermos algo
guardado em diamantes, retire-o e
coloque-o nos diamantes do ensino médio Então, os
diamantes salvos são vazios aqui. Se nossa pontuação atual
for melhor do que isso
, queremos substituí-la. Tudo o que vamos fazer abaixo
disso é
clicar em Preferências do jogador, Salvar . Vamos colocar tudo
isso dentro da declaração. Esse será
praticamente todo o código de
que precisamos para
salvar nosso jogo e fazer com que as coisas funcionem entre as sessões. Tudo o que precisamos fazer agora é
obviamente chamar isso de vazio. Vamos voltar à saúde do jogador. No minuto em que morrermos,
isso também será anexado
ao nosso jogador. Vamos lá. Objeto do jogo, pegue os diamantes do
Component Player, salve os diamantes Vamos testar isso.
Se voltarmos ao nosso jogo, clicaremos no meu jogador. Podemos ver que todos
os
nossos valores padrão estarão
aqui. Vamos clicar em Jogar. Vamos ver se
temos diamantes zero
e diamantes do ensino médio E isso não vai mudar.
Não vamos cometer nenhum erro porque
usamos isso como algo fundamental. Vamos ver se podemos
tentar conseguir um diamante. Não parece ter tido
sorte até agora. No minuto em que tivermos um,
vou
testar esse código. Eu tenho um diamante, agora os diamantes
atuais estão definidos como um. Eu vou morrer.
Vamos ver se funciona. Atualmente,
vamos redefini-lo. Agora, vamos fazer uma pausa rápida e, se voltarmos para o meu jogador, poderemos
ver que, de fato, temos
diamantes do ensino médio cravejados
em um Na próxima vez que eu morrer, não terei
mais do que um diamante. Então, vou reiniciar
meu jogo novamente. Vamos ver se tudo funciona exatamente como
prevíamos Ainda temos
diamantes do ensino médio cravados em um, e isso realmente funciona, não importa quantas vezes
você jogue o jogo, não importa quantas vezes
você o feche ou algo assim O sistema de salvamento funcionará
porque
agora estamos salvando o valor do nosso
jogo em um arquivo separado. Isso é tudo o que
precisamos
fazer para que o salvamento funcione no meu jogo. Obviamente,
adicionarei um hub inicial mais tarde onde poderei mostrar
a pontuação mais alta
do jogador, bem como o
título e tudo mais. Mas, por enquanto, podemos saber que tudo está funcionando
como deveria. Essa é realmente a última mecânica que precisamos adicionar
ao nosso jogo. Depois disso, vamos
melhorar o visual
e
adicionar o hub inicial e
todas as outras coisas extras, melhorias visuais e
de áudio Mas, por enquanto, esse é o último passo para
criar nosso jogo. E fizemos
tudo até agora. Um ótimo trabalho se você
acompanhou até o ponto em que estou. Agora, obviamente, ainda precisamos fazer alguns ajustes com porque alguns deles
são impossíveis E talvez faça um
pouco de depuração para garantir que nosso jogo
pareça um Mas até agora, tudo
está realmente funcionando da maneira que
você esperaria. E parece que não
temos grandes
problemas no momento. Portanto, nosso jogo está em um estado
muito bom e temos toda a mecânica básica, como eu disse, se você
conseguiu acompanhar e seu jogo é como o meu no
momento, ótimo trabalho Porque esse é, na verdade um
jogo muito impressionante de se ter feito, especialmente se você nunca fez jogos
Unity no passado. Ótimo trabalho em acompanhar este
vídeo até o final. Certifique-se de estar
atualizado com este vídeo antes de
assistir ao próximo, pois então
adicionaremos o último
toque ao jogo. E você quer chegar a esse
ponto antes de seguir em frente. Mas espero que
tudo funcione no seu computador da mesma
forma que no meu. No próximo vídeo,
começaremos a adicionar nossas
melhorias visuais. Obrigada.
15. 14. Melhorando imagens, recurso visual: Olá, e bem-vindo de
volta à Unity. Agora eu mencionei no
último vídeo que
praticamente terminamos todos
os conceitos básicos do nosso jogo E eu sei
que já disse isso algumas vezes, mas na verdade é
praticamente verdade. Agora, fizemos tudo o que você precisa para
uma plataforma básica. Novamente, temos uma geração aleatória de mapas
infinitos. Temos um ciclo de jogo,
você pode morrer e recomeçar. Temos um
sistema de pontuação com salvamento, e temos um monte de inimigos, obstáculos variados
e tudo mais. E, obviamente, como eu
disse, você pode morrer e reaparecer e tudo
será salvo. E está tudo
funcionando praticamente como precisávamos. Mas há algumas coisas
que não adicionamos. Em primeiro lugar, um
deles é um hub inicial, que abordaremos um
pouco mais tarde no curso, para que você não precise
voltar imediatamente ao jogo. Você pode relaxar um pouco. Em segundo lugar,
não temos como mostrar suas pontuações mais altas, embora estejam salvas,
elas não estão realmente lá. E também colocaremos você
no centro inicial. Mas o mais importante é que o jogo ainda não parece muito bom. Se eu prosseguir e
desativar essa cortina, se você puder, exatamente como eu, você pode simplesmente desativá-la
sempre que precisar ,
porque tudo o que ela fará é desativar o fade na animação Na verdade,
desativamos isso e, posteriormente, o reativamos por meio de código. O fade out
ainda funcionará, mas se você quiser ver
coisas no seu jogo sem precisar desativá-lo
e movê-lo, basta desativá-lo por enquanto Eu vou fazer isso, o
jogo não parece ótimo. Temos esse fundo enorme,
grande e azul escuro. Não temos nada acontecendo em
segundo plano. Ainda não
temos realmente nenhum efeito quando morremos
ou coletamos moedas. Nós apenas
trocamos todos eles de sprite imediatamente. Vamos mudar tudo
isso neste vídeo e começar com uma
atualização visual para o jogo. Mas antes de
começar com isso, pensei em mencionar que mudei alguns
desses ladrilhos entre
este e o último vídeo. Agora, isso não tem importância
alguma, porque tenho quase certeza de que você não tem exatamente
os mesmos
ladrilhos que eu tenho Mas alguns dos meus ladrilhos eram impossíveis de passar. Só pensei em
mencionar que, se alguém perceber que eles parecem um pouco diferentes, mudei algumas
coisas Por exemplo, eu movi isso um pouco para cima e isso para baixo, acho que isso
costumava ser impossível, então eu mudei isso para cima também.
E esse eu mudei para baixo. Eles são praticamente os
mesmos que eram, apenas com algumas
pequenas alterações. Mas, como eu disse, isso
não é nada importante. Achei que tinha
mencionado isso para o caso alguém ficar confuso e
notar a diferença. Mas, de qualquer forma,
vamos
começar a atualizar o
visual desse projeto Vamos entrar em sprites e usar novos ativos importantes,
como sempre fazemos Obviamente, esses dez ativos
de sprites aqui sempre estarão vinculados abaixo do vídeo e também estão
abaixo deste Vamos selecionar todos os dez novos sprites que
acabamos de coletar lá E então vamos definir
todas essas configurações para um único 12 e apontar sem filtro. Obviamente, se seus pixels por unidade forem diferentes,
use seu próprio valor. Mas você deve definir isso
para usar pixel art. E vou
definir o single boa medida porque tivemos alguns problemas
com o coração, mas não é um grande problema. De qualquer forma, vamos começar arrastando esse
plano de fundo para o nosso jogo Na verdade, nunca criamos
um objeto como esse antes, mas ele cria
automaticamente um objeto sprite com esse sprite
atual Acho que fizemos isso uma vez e
vou fazer novo porque
é a maneira
mais fácil de criar um sprite Então, tudo o que vou
fazer é
arrastá-lo para baixo da minha câmera
principal desta forma, e vou me certificar de
que agora é um objeto filho da câmera principal e
vou zerar sua posição Na verdade, isso vai me
permitir fazer com
que ela esteja sempre em movimento
com a câmera principal. Se eu mover a
câmera principal dessa forma, você pode ver o fundo
se mover com a câmera principal. Você pode imaginar que, enquanto
jogamos o jogo, será
algo parecido com isso. Isso sempre
estará em segundo plano, o que é
exatamente o que
queremos para um
objeto de fundo como esse. Então, vamos seguir
em frente e garantir que seja um objeto filho
como esse, e definimos sua
posição como zero. Então, se prosseguirmos
e
clicarmos em play, podemos realmente
ver a diferença que
isso já faz em nosso jogo. Agora temos um jogo muito
mais bonito. Não temos esse tipo de coisa azul
aleatória
no fundo. Agora temos uma espécie de aparência
realmente boa. Jogo. Mas
há alguns problemas. Em primeiro lugar, nossos
corações se foram. Parece que eu sofro
danos aleatoriamente nessa coisa. E parece que não
há nenhum inimigo. Mas eu ainda estou sofrendo danos , exceto esses,
por algum motivo. A razão para isso tem a ver
, na verdade, com a ordem e a camada
de nossos sprites A maioria dos meus sprites está configurada
na ordem e na camada zero porque esse é o padrão e não
causa problemas Mas agora que
adicionamos um plano de fundo que também tem ordem
e camada zero, ele simplesmente
ganha prioridade aleatoriamente sobre esses sprites, então não
podemos ver nada Vamos definir isso para algo
como menos cinco. Não importa
o que você definiu, desde que seja menor do que
o resto do jogo. Vamos também reiniciar minha câmera principal, porque eu realmente
não percebi. Mas eu a movi
um pouco para a esquerda, então é por isso que a primeira
nuvem estava um pouco desligada. Agora, se
tivéssemos que jogar, conseguiríamos
ver se esses problemas
foram resolvidos, se
temos nosso coração e
nosso pequeno contra-ataque, e agora temos coisas normais que
geram diamantes E podemos ver que isso já
faz com que o jogo pareça muito melhor. Nós meio que tivemos uma
grande melhora, mas na verdade não temos mais
nada em segundo plano. Nós meio que acabamos de ter esse céu e temos essas
nuvens surgindo, que são o primeiro plano
e o Mas não temos
nada interessante
em segundo plano. E eu criei
essas
nuvens de fundo e essa águia, que serão muito interessantes de se ver
voando pelo nosso jogo, mas ainda não as adicionamos Para fazer isso, precisamos
escrever um roteiro. Porém, antes de escrever meu roteiro, vou fazer um
pré-fabricado para tudo isso Porque se você adivinhou, nós
os geraremos
exatamente como geramos
o resto do nosso mapa, só que eles ficarão em segundo plano, então
não
serão realmente importantes,
serão apenas sprites que se moverão para nuvens Vou fazer exatamente o que
fiz com o plano de fundo. Basta arrastá-los até lá, como se estivesse vendo todos eles na tela agora,
eles parecem bem legais. Talvez eu tenha que realmente mudar isso evidente, um pouco menos Então você pode ver que
eles não fazem parte do jogo e fazem
parte do plano de fundo. Mas vou me preocupar com
isso em um minuto. Primeiro, deixe-me
fazer meus pré-fabricados. Vou até os
prefabs e ligo. Na verdade, vou
mantê-los nomeados como nuvem de fundo 12.3. Acho que isso
os resume muito bem Agora vou deletar
esses objetos da minha cena. Agora eu tenho meus três pré-fabricados com minhas
nuvens de fundo aqui Antes de começar
com qualquer outra coisa, vou
adicionar um corpo rígido
que pode parecer um pouco confuso, mas tem a
ver com a forma como eu quero minhas nuvens se movam
pelo ar Vou
usar corpos rígidos para mover as nuvens
pelo céu Vamos seguir em frente e colocar três corpos
rígidos e dois D's neles Selecione todos eles e,
na verdade, certifique-se de que também estejam configurados para cinemática Agora que tenho, tenho que
fazer isso manualmente. É um pouco vergonhoso. Lá vamos nós. Eu devo
ter perdido essa. Tudo bem, agora eu tenho três corpos rígidos
cinemáticos
adicionados às E isso é realmente
tudo que eu preciso para eles. Mas o ego é um pouco
mais complicado porque, obviamente, a
águia tem uma animação Em vez de animar
isso como fizemos, vou mostrar um truque Se você selecionar quatro
sprites e arrastá-los, Unity já cria uma
animação para você, como automaticamente, porque essa é a única animação que
queremos ter Na verdade, vai
funcionar perfeitamente. Vou nomear essa águia na verdade, nós que criamos para nós Temos essa águia,
um sprite aqui, temos um controlador de águia E se abrirmos o
animador, podemos ver que já
temos essa animação de águia, que se clicarmos duas vezes
nela , ou melhor, abri-la assim, podemos ver que
temos uma animação de ego, que mudará
de todos os meus quatro sprites Se eu for até minha águia
e clicar em Jogar, poderemos ver que está funcionando
perfeitamente, o que é ótimo Na verdade, isso é praticamente tudo que
eu teria que fazer,
mas, feito por mim,
não acho
que essa batida seja necessariamente
a melhor velocidade Vou
mudar isso para uma velocidade de reprodução de 0,5 e, se eu clicar em reproduzir, poderei ver
isso na ação E deixe-me ver se eu decido, acho que isso é muito
melhor para uma águia Mas basicamente
o que fizemos aqui, você não pode fazer manualmente. Fomos a uma animação e
criamos um novo clipe de animação, adicionamos um componente animador E, obviamente, quando
criamos nosso clipe, isso criou um
controlador para nós
e, em seguida, transformamos nosso clipe
na animação padrão. Mas, obviamente, a Unity meio
que fez tudo isso por nós. Se você quiser fazer isso
manualmente, você também pode fazer isso. Basta seguir exatamente o mesmo
processo que fizemos antes. Mas se você quiser
criar um objeto rapidamente e uma animação e
precisar apenas de uma animação, ou quiser ter algo assim em
que seja uma animação, ela sempre estará sendo reproduzida. Essa é uma maneira bem
fácil de fazer isso. E então você pode simplesmente
alterar a velocidade de reprodução, algo que você goste Esse é o meu Eagle Done. Deixe-me prosseguir e arrastar isso
para os pré-fabricados também. Vou renomear isso para
Eagle em vez de Eagle One. Então, tudo o que vou
fazer é abrir isso e
voltar à minha cena e adicionar um corpo rígido,
assim como fiz os outros, exceto
tornar este Kinematic Agora, o que vou
fazer é
escrever alguns roteiros curtos. Basicamente, vou
ter um script que vai
aparecer em uma águia e outro script que
vai aparecer nas nuvens E eu vou fazer com que eles
viajem pela velocidade, em velocidades aleatórias
pela tela. Em velocidades aleatórias, hum, de uma faixa especificada. E então, no minuto em que alcançarem uma certa coisa
do outro lado, eles serão desativados Agora, não vou
usar nenhum tipo de limite no
lado direito da tela Eu não vou dizer que coloque um
limite aqui e diga,
ok, se a águia atingir Porque eu não quero que o
jogador consiga
ultrapassar limites e morrer
daquele lado da tela. Acho que só
precisa estar à esquerda. Você deve ser capaz de
avançar no jogo. Vou precisar
codificar manualmente. Preciso dizer que uma vez que essa posição é aprovada em uma determinada posição
, você precisa encerrar o dia. Na verdade, vou
fazer isso de
uma forma um pouco leve, mas vai
funcionar muito melhor. Eu vou ter um objeto
limite aqui, e vou
movê-lo dessa forma E então tudo o que vou fazer é, em vez de tentar calcular
constantemente, ok, onde estou me referindo
à câmera principal? Qual é a distância entre minha posição real
e minha posição relativa? Eu vou dizer que no minuto eu passar desse objeto limite, eu realmente vou
colocá-lo do outro lado porque as coisas vão surgir de ambos os Então, deixe-me movê-lo um para
lá e outro para lá. Digamos que, no minuto em que eu ultrapasse um desses objetos
limite
, posso encerrar o dia
e pronto O E vai
voar da direita para a esquerda e as nuvens
vão da esquerda para a direita. Então, eu só preciso ter certeza de que estou acompanhando
qual é qual. Mas isso vai
funcionar muito bem. Vou chamar isso de
limite à esquerda. Vou ligar para esse
aqui, Boundary, certo? Isso vai me
permitir
acompanhar o que está onde. Vou mudar isso
para -11,5 e fazer isso
111,5 . Então, no minuto em que
meu objeto passar desse ponto, terei um spawn Na verdade, vou mover
isso um pouco
dessa maneira porque as
nuvens são muito grandes e eu não
quero que elas apareçam fora tela e sim na tela.
Vamos fazer com que seja 14. As águias são bem pequenas, então acho que 12 deveriam
ser boas aqui Isso é praticamente tudo o que precisamos fazer para montar nossa cena. Agora só precisamos escrever o
script para essa desova. Vou parar os Eagles, vamos criar um script em C sharp
e chamá-lo de eagle Vamos clicar duas vezes
nele para abri-lo. Agora tudo o que precisamos fazer é escrever
um código que diga, ok, cada intervalo aleatório
surge em uma nova águia Vamos criar um,
vamos chamá-lo de float. Chamaremos isso de mínimo de
Y
e máximo de Y, e é aqui que
queremos aparecer no eixo Y. Em seguida, vamos criar
outro carro alegórico público, chamado de tempo mínimo
e tempo máximo Esse é o tempo que queremos
esperar entre as águias. Então, tudo o que precisaremos fazer é criar uma referência
ao meu objeto de
jogo público pré-fabricado Eagle Então, antes de começar,
vou excluir essa atualização anulada e
criar uma nova rotina Em numerador, chame
isso de atraso de geração. Então, dentro disso, tudo o que vou fazer é dizer rendimento, devolver o novo peso por segundos, do tempo mínimo até
o tempo máximo. Vou esperar por um número
aleatório lá dentro. Na verdade, esqueci meu intervalo de pontos
aleatório. Deixe-me escrever um intervalo aleatório do tempo mínimo
até o tempo máximo. Ele escolherá um número
aleatório dentro desse intervalo e
aguardará o longo
minuto concluído Quero criar um novo vazio. Chame isso de spawn eagle. Vamos voltar aqui e
chamar minha águia de desova de vazia. Então, no minuto em que fizermos isso, agora só precisamos codificar essa coisa real
aqui,
que determinará o que fazer quando quisermos gerar uma águia A primeira coisa, assim
como eu fiz antes, é dizer que objeto de jogo para águia é igual a
instanciar águia como
objeto instanciar Em outras palavras, crie uma instância desse
prefab no meu jogo Agora quero que minha posição S
fique atrás da câmera principal. E esse script
, na verdade será anexado
à câmera principal. Deixe-me dizer que a
oposição transformada é igual ao novo vetor três Deixe-me criar uma
variável de deslocamento aqui em cima, assim como fizemos
o tempo todo Vamos lá, minha
oposição transformada. Faça a câmera mais esse deslocamento, e será
um valor negativo Porque eu quero ficar para trás. Então eu vou querer escolher um número aleatório dentro do meu Y
mínimo e máximo Y. Vamos para o intervalo aleatório
entre min Y e maio Então eu vou definir meu Z para zero porque
é um jogo de dois D, realmente
não
faz diferença. Então, tudo o que eu realmente preciso
fazer agora é criar outro script que será
anexado ao Eagle E eu vou dizer, ok, viaje por tanto tempo. E então, no minuto em que eu estiver atrás desse limite, exclua Vou escrever o mesmo roteiro para a
Águia e a Nuvem Vou chamá-lo de objeto celeste. Isso tornará isso um pouco
mais complicado de fazer, mas também será uma maneira um pouco melhor de codificá-lo. Vamos dobrar o conteúdo
dentro do script. Vamos querer
uma transformação pública. Vamos chamá-lo de limite. Essa coisa
que vamos observar. Vamos ter um
booleano público e vamos
chamá-lo de viajar da maneira certa, porque obviamente a águia vai
viajar As nuvens vão viajar
para a esquerda. Então, vamos usar para
determinar em que direção estamos indo. Então, por baixo disso, a última coisa que precisamos é uma
referência a um corpo rígido Obviamente, vou
arrastar isso quando tiver
meus objetos
criados dentro do meu jogo. Vou
colocá-lo nos pré-fabricados. A última coisa que eu quero é um carro alegórico
público chamado velocidade. Tudo o que vou fazer na
atualização fixa é dizer em
cada quadro, garantir que minha velocidade
do meu corpo rígido igual a um novo vetor dois e qualquer que seja minha
velocidade,
além de zero, porque eu não
quero que eles se
movam para cima e para Agora vou até cada quadro, para ter
certeza de que estou
viajando dessa maneira. Então, embaixo de
cada moldura, também. Vou dizer que, se estiver
viajando nesse momento, sei que tenho que
estar atrás da fronteira Se eu estiver à frente do limite, quero ter certeza de destruir essa instanciação
dos objetos Eu vou dizer se estou
viajando bem. E então, dentro disso,
vou dizer que se a posição de
transformação x for
maior que a posição limite x, então eu quero ter certeza de
destruir essa instância
do meu objeto de jogo Em outras palavras, exclua qualquer objeto ao qual ele esteja anexado. Se eu não estou viajando para a direita, significa que estou viajando para a esquerda. Então, deixe-me copiar esse código exato. Basta dizer que se minha posição de
viagem x for menor que meu limite, quero destruir essa
instância do objeto do jogo Na verdade, esse é todo o código de que
precisamos para garantir que nossos objetos
viajem da maneira certa. Mas, obviamente, precisamos
atribuir valores a isso, porque no momento isso não tem absolutamente nenhum valor para limite, viagem para a
direita ou velocidade Ele só tem um valor corporal rígido. Vamos voltar ao spawn de águias e criar algumas novas variáveis Bóia pública,
velocidade mínima e velocidade
máxima e é
assim que vamos escolher
a velocidade de nossas águias Vamos pegar o componente e encontrar script
do objeto celeste
em cima do nosso Eagle Vamos dizer que a
velocidade é igual à faixa
aleatória entre
nossa velocidade mínima
e nossa velocidade máxima Agora temos essa velocidade
verificada e obviamente, já
temos o corpo da crista que vai arrastá-la para dentro Agora precisamos dessa variável
viajando para a direita. E sabemos que, para uma águia,
isso será verdade. Vamos
copiar toda essa linha de código para chegar até aqui e dizer que
viajar
para a direita é igual a verdadeiro porque es
vai se mover
da esquerda para a direita. Por fim, precisamos desse limite e
vamos criar
uma referência ao limite para que as águias aqui em cima se transformem,
chame-a de Eagle bound chame-a Então, vamos copiar o código novamente. E aqui embaixo, basta dizer que dardo é
igual ao limite da águia Na verdade, vamos chamar essa rotina desde o início do jogo, no minuto em que
começamos a aparecer Nesse comportamento, espere alguns segundos e
comece a desovar em uma águia, que é praticamente
tudo o que precisamos fazer Tudo o que precisamos agora é
realmente atribuir todas essas coisas no editor
e testar se funciona. Eu acho que deveria.
A única última coisa que precisamos acrescentar
por trás de tudo isso é, obviamente, chamar
a corotina novamente, para que possamos dizer se
queremos gerar Obviamente, isso
continuará jogando mesmo depois que o jogador estiver
morto. Mas tudo bem. Você pode ter nuvens passando e águias voando após
a morte do jogador Não é um grande problema. E, obviamente, o
jogador só está morto por cerca de 2 segundos de qualquer maneira. Então, isso realmente não
faz diferença. Mas esse é todo
o código que precisamos. Estamos começando nossa
cotina no início. Estamos dizendo, ok,
espere alguns segundos. Em seguida, crie essa águia, defina sua posição
atrás de nós e, em
seguida, uma posição y aleatória e , seguida, certifique-se de que sua velocidade
seja O fato de ele estar
viajando da maneira certa é verdade e estabeleceu esse
limite para essa coisa E então, dentro do Eagle, atribuímos todos esses valores aqui e em
cada quadro, estamos nos certificando de que
estamos viajando
na velocidade certa e verificando se não estamos além de
onde deveríamos estar Vamos abrir o Unity,
voltar para nossos prefabs e adicionar esse script de
objetos celestes ao nosso A única coisa que vamos
assinar é o corpo rígido. Todo o resto será feito por nós. Na verdade, só por
uma questão de eficiência, vamos adicioná-lo
às nuvens também. Por enquanto, só para não
precisarmos fazer isso mais tarde, vamos usar objeto celeste aqui até esta nuvem objeto celeste
aqui até esta nuvem e objeto
celeste
aqui até esta nuvem. E certifique-se de arrastar
nossos corpos rígidos. Você não precisa
fazer isso agora, mas
vou então ir para a câmera principal e
adicionar novos componentes. E vamos adicionar
meu criador de águias aqui. Vou definir
o y mínimo 0,6 e, em seguida,
o máximo y como,
digamos, 2,5 menos 0,6 e 2,5. Vamos
atribuir isso aqui,
menos 0,62 0,5.
Eu diria que quero que o tempo mínimo entre as águias seja de
pelo menos 10 segundos e o tempo
máximo seja
algo em torno Vou colocar
essa águia aqui. Acho que a compensação.
Vamos apenas testá-lo. Mas provavelmente deveria ser um, eu diria que talvez menos 12. Se olharmos para a
câmera principal na posição zero, o jogador está
atualmente com menos 12. É aí que eu quero que
os Eagles apareçam. Vamos definir isso também. Vá aqui e parta para menos 12, depois para a velocidade mínima. Vou
começar às três e definir a velocidade máxima para quatro. Lembre-se de que a
câmera está se movendo
atualmente em 1,8. Ela será
mais rápida que a câmera, mas pode não ser
muito mais rápida, o que é bom. Na verdade, vamos configurá-lo para 2,5
e 3,5. Então, por último, amarrado à
águia,
vamos definir
como limite da mão direita aqui Vamos ver se tudo
isso realmente funciona. Se eu apertar o
botão play, certifique-se de que
não esquecemos nada
nem encontramos nenhum bug. Vamos ver, aqui, estamos jogando o jogo no
momento. No minuto em
que a desovarmos, devemos ter essa águia, que
aparece atrás Então, vamos ver se
observamos lá. Oh, isso foi um diamante. Opa Estaremos pelo menos 10
segundos antes de vermos um. Ah, tem um
ali mesmo. Nós temos uma águia. Isso parece um pouco
com um inimigo. Eu não vou mentir. Então, teremos que
aumentá-lo um
pouco só porque não sei se deveria estar exatamente onde está. Na verdade, vou
definir um pouco
o limite e também vou me
certificar de que o tempo seja um pouco diferente,
porque na
verdade não queremos tantas águias Vamos fazer alguns ajustes. Vamos definir o y
mínimo como um, o máximo y como três. Vamos que o tempo mínimo seja
de 10 segundos e o tempo máximo seja
algo em torno de 20 segundos. Então vamos fazer com que a velocidade
mínima seja máxima. Acho que os dois são bons. Talvez possamos deixar
a águia um pouco mais transparente para que ela não pareça fazer parte do jogo Vamos fazer isso 180. Essa pode ser uma
escolha de design estranha, mas confie em mim, vai fazer com
que pareça um
pouco mais distinto, que ele realmente não
faz parte do Obviamente, podemos ajustar
isso conforme necessário, mas vamos testar como
isso funciona por enquanto Obviamente, temos que esperar
um pouco para que a coisa apareça, mas ela deve
estar saindo. Tem uma águia
ali mesmo. E aí está. Você pode ver que parece que está
embaçado pelas nuvens. Mas isso parece muito
legal na minha opinião. Obviamente, precisamos
adicionar mais algumas nuvens e isso fará com
que pareça muito melhor. Mas, por enquanto, acho que
os Eagles são um sucesso. Não
pretendia fazer isso. Podemos ver que temos
alguns deles. Talvez até tenhamos
que prolongar esse tempo um pouco mais. Mas vamos
mudar isso rapidamente. Na verdade, quero fazer
isso em 30 segundos e dez, e depois vou fazer com que
eles também sejam um
pouco mais rápidos para
que possam passar voando. Mas esse é
praticamente todo o script de
desova de águias de que precisamos Agora temos que
começar nas nuvens. Na verdade,
o script da nuvem será muito semelhante
ao script Eagle Vou copiar tudo
isso
e criar um novo script, chamado de cloud spawn Na verdade, vou
colar a coisa toda. Agora, há algumas coisas que
eu tenho que ter em mente. Em primeiro lugar, isso vai
me causar um monte de erros porque eu tenho a mesma classe aqui sem explicar
muito o que é uma classe. Basicamente, é assim que a unidade diz, ou melhor, a
nitidez diz a unidade. Que tipo de identidade do código. O fato de eles
terem o mesmo nome
agora é um problema. Vamos mudar
isso para cloud spawn. Tem que ser exatamente o mesmo
nome que você tem aqui. E isso deve realmente eliminar cada
um dos nossos erros. Agora você pode usar todos os
mesmos nomes de variáveis, nenhum desses problemas de seção, mas obviamente precisamos
alterar alguns deles. Vamos primeiro
mudar isso para gerar uma nuvem, depois teremos que
atualizá-la também Então, vamos mudar isso
para nuvem para vinculado à nuvem. Pode parecer que
poderíamos ter feito isso em um script e,
honestamente, poderíamos ter Achei que seria melhor
fazer duas só porque
vamos
fazer algumas diferenças
e alterações E será um pouco mais fácil entender se tivermos
dois scripts diferentes, em vez de
tentar agrupá-los em um e gerar águias e
nuvens simultaneamente Sim, poderíamos ter feito
isso em um script, mas vou usar dois. Por uma questão de eficiência,
ou melhor, de simplicidade, posso manter esse Y mínimo e Y máximo porque ainda
preciso disso. Obviamente, ainda quero meu tempo. Eu tenho minha nuvem de objetos de jogo. Eu quero meu offset
exatamente como estava. Obviamente,
será um valor positivo agora. E eu tenho minha velocidade mínima
e máxima , que serão
diferentes, e minha transformação, praticamente todo o resto na verdade, podemos manter o mesmo. Temos o atraso na geração. Vamos
instanciar uma nuvem. Estamos surgindo em uma posição, estamos dizendo isso a
uma velocidade aleatória Vamos definir a viagem
até as falhas aqui e garantir que
tenhamos o limite certo Isso deve ser
praticamente tudo o que precisamos para nossas nuvens. Vamos voltar ao meu jogo. Vá para minha câmera principal. Agora vou adicionar esse script de geração de
nuvem
abaixo dele E, obviamente, você pode ver
que é muito parecido com o script Eagle porque é praticamente o mesmo script Podemos praticamente usar exatamente a mesma coisa, mas temos um
pequeno problema. Só temos um
objeto aqui para uma nuvem porque
só tínhamos uma águia Mas para as nuvens, precisamos
escolher entre três aleatoriamente. Na verdade, isso é muito
fácil de fazer. Tudo o que precisamos fazer é transformar
isso em uma matriz. Então, em vez de dizer
instanciar nuvem como objeto, diremos instanciar colchetes
abertos, intervalo
aleatório de zero
até o comprimento da Então, vamos usar o comprimento do ponto da nuvem
e, em seguida, fechar o colchete. Feche o colchete. E isso deve ser tudo o que
precisamos fazer agora. Basicamente, estamos escolhendo uma coisa
aleatória dessa matriz Em vez disso, vamos
voltar para o Unity. Se rolarmos para baixo,
podemos ver que agora temos uma matriz de nuvem,
que é o que precisamos. Vamos arrastar todos os nossos três
objetos até aqui. Vamos definir o Y mínimo como zero e o
máximo Y como três. Então você pode ter a geração de nuvens. Na verdade, vou
fazer esse mínimo Y
menos dois e o
máximo Y três, vou definir
o tempo mínimo para 2 segundos e o
tempo máximo para 4 segundos. Vou definir a velocidade
mínima para menos
um e a
velocidade máxima para zero. Quanto menos 0,5 o deslocamento, eu vou fazer 12
porque é o contrário Isso deve ser praticamente tudo o que precisamos até
agora, obviamente. Apenas certifique-se de que temos
nosso limite à esquerda. Quase clique no limite
errado, limite à
esquerda como limite de nossa nuvem Vamos descer e verificar isso. Vamos ver se isso funciona. Se clicarmos em jogar agora,
poderemos ver a nuvem surgindo da direita
logo após começarmos a
jogar Vamos
ver se está funcionando. E aí temos uma
nuvem que está surgindo. Mas isso obviamente parece parte do jogo. Isso é um pouco problemático para nós, porque
obviamente queremos isso. Também podemos
vê-los surgindo, que também é um pouco problemático Claramente, temos
que fazer essa compensação um pouco mais e torná-la
um pouco mais transparente Vamos fazer com que o deslocamento seja
algo mais parecido com 20. Então, vamos examinar
cada nuvem e talvez tornar o alfa algo como
180 em vez de 255 Isso pode ser um pouco drástico, mas podemos
ajustá-lo à medida que avançamos Acho que deve
ficar bem por enquanto. Vamos voltar ao meu jogo, e acho que as nuvens também podem passar um pouco mais rápido
pelo jogador. Vamos voltar para a câmera principal e fazer com que a
velocidade mínima seja negativa. E a
velocidade máxima é menos
0,5. Na verdade, eles estão sempre
se movendo. Agora vamos ver se isso
parece um pouco melhor. À medida que estamos surgindo no jogo, devemos ser capazes de
ver a nuvem surgindo
logo em seguida, ela vem
do lado em que temos uma
nuvem que realmente torna o jogo muito
mais bonito, obviamente Agora, há um pequeno atraso no início, pois
não temos nenhuma nuvem para tornar a simplicidade
um pouco mais fácil. Vou apenas arrastar
algumas do início do jogo,
assim, e fazer com que o jogo pareça um pouco mais vivo desde o início. Obviamente, terei que
definir esses valores de velocidade por
conta própria , porque esses
são casos especiais, eles não são atribuídos à mídia Formando, vou fazer com que a velocidade seja negativa
0,5. Também vou
alterá-las e
vou me certificar definir o limite para
o da esquerda Então, deixe-me
prosseguir, na verdade vou definir a velocidade
para zero por enquanto Eles só são destruídos
quando passamos por eles. Vamos ver se
isso parece um pouco melhor. Talvez esse, muito
específico, possa ter uma velocidade de menos 0,2 e este possa ter menos
0,1. Só para dar um pouco de singularidade, se continuarmos e clicarmos em jogar
agora, podemos ver nossas nuvens
e nossas
águias estão agora em nosso E isso faz com que pareça, na
minha opinião, muito melhor. Ainda há uma pequena lacuna
estranha por aqui. Então, vou adicionar
talvez mais uma nuvem ali só para
que pareça um pouco melhor. Mas acho que esse é, na verdade,
um começo muito legal para as atualizações visuais de nossos projetos. E, na verdade, fizemos
muita coisa até agora. Obviamente,
adicionamos o fundo as águias e as nuvens
e, na minha opinião
, está
muito melhor do que Mas há mais duas
coisas que precisamos acrescentar. E eles são muito fáceis de adicionar, não
são muito complicados. Na verdade, isso também
adiciona um bom efeito onde as bolas de espionagem estão escondidas, o
que torna o jogo um
pouco mais difícil Mas acho que, no geral,
isso faz com que o jogo pareça muito
mais bonito e vivo pois você
meio que pula pelas nuvens em vez
de apenas vagar por
esse tipo de massa azul E podemos ver que as nuvens estão sendo destruídas, exatamente
como deveriam ser. As águias estão se
divertindo. Mas eu estou
lá, aqui está o nosso primeiro. Acho que isso faz com que o jogo pareça
muito melhor, o que é muito legal Mas de qualquer forma, como eu estava dizendo, não
há efeito de partícula, não só quando você
coleta um diamante, mas também quando você morre E acho que
você descobrirá que, ao adicionar essas pequenas
coisas ao seu jogo, isso faz com que pareça muito mais
impressionante a longo prazo. Especialmente para
alguém que não sabe
necessariamente o
quão simples eles são. Na verdade, adicionar faz com o jogo pareça muito
mais impressionante do a quantidade de trabalho
necessária para ser adicionado. Então, eu vou te mostrar
exatamente como fazer isso agora. Vamos ao
meu sprite de diamantes. Vou adicionar um componente
chamado sistema de partículas. Agora, esse é sem dúvida um
dos componentes
mais complicados de todo o Unity Eu nem entendo totalmente
como funciona, para ser honesto, mas descobri uma maneira de trabalhar com isso
que geralmente
funciona na maioria dos meus jogos. E acho que também é uma maneira muito
fácil de fazer isso. Então, eu vou te mostrar agora sem entrar em
muitos detalhes. Obviamente, esse
sistema de partículas é baseado em um monte de coisas
diferentes aqui, que você
pode ver listadas Temos velocidade de
vida, forma, emissão, renderização de todas essas coisas muito
complicadas, mas na verdade não precisamos nos
preocupar com a maioria
delas por enquanto Na verdade, vou mostrar quais permitirão, precisamos emissão
e
precisamos de forma. Não precisamos de nenhum desses. Precisaremos de
cores ao longo da vida útil e precisaremos de
tamanho ao longo da vida. Então, nenhum dos outros
deveria ser tão necessário. Talvez precisemos habilitar a animação
da folha de
texto , dependendo do que queremos fazer. Mas vamos tentar
assim por enquanto. Depois de ativar esses cinco menus diferentes, abra o renderizador
e certifique-se de definir esse material como o material padrão
dos sprites Agora estamos surgindo
em sprites aleatórios. Na verdade, há
mais uma coisa doentia. Precisamos adicionar esse
texto, uma animação em folha. Vamos selecionar
isso. Vamos selecionar o modo para serem sprites E vamos seguir em frente
e isso é para o nosso diamante, queremos desovar em nosso diamante, sprites estelares,
vamos escolher a
estrela Agora temos um monte de estrelas voando desse diamante, que parece muito
legal por si só. Não vou mentir,
mas só queremos que isso aconteça depois de
coletarmos o diamante, configurarmos nossa
animação de textura e a única coisa que
precisamos alterar no renderizador é esse material Depois de fazer isso, temos tudo o que precisamos
desses dois menus. Os últimos
vêm desses que estão aqui. Vamos começar
acessando meu menu original,
na verdade, aqui no topo.
Isso também é um menu. Vou fazer com que a
duração seja de 0,3 segundos. Vou iniciar o loop, vou fazer com que a
vida útil inicial desses 1 segundo,
ou melhor, 0,6. Na verdade,
obviamente, você
precisará ajustar isso à medida que E vamos ver como
isso fica aqui. Temos algumas coisas surgindo, o que parece muito
bom para mim até agora Eu quero que o tamanho inicial seja um
pouco menor. Vou fazer o
tamanho inicial dois, ver como fica. Na verdade, vou manter
isso em um por hora, porque o que está sendo executado é o tamanho de uma vida útil, não esse valor. Vou definir os 0,3
segundos, sem repetir. Zero para o atraso inicial é
0,6 para a vida útil inicial. Cinco para uma velocidade inicial é bom e um para um tamanho inicial. Vou manter o resto como
estão por enquanto. Em seguida, altero essa taxa ao longo do tempo de emissão
para algo como 30 e vejo
como é . É
muito mais. Acho que também deve estar
tudo bem por enquanto. Vamos prosseguir com a forma. Essa forma é um cone. Isso realmente não
importa muito. Usamos, poderíamos usar
uma esfera também. Vou usar uma esfera e vou fazer com que o raio 0,2. Então, todas elas vêm do centro
do diamante Eu acho que isso também parece
muito legal. Agora precisamos
colorir ao longo da vida. Se for difícil acompanhar isso, não se preocupe muito, porque
vou revisar
tudo o que fizemos. Mas tente seguir o
melhor que puder agora. Vamos para Color over Lifetime. E agora vamos
abrir essa janela aqui. Vamos clicar em Mu.
Então, vamos até essa coisa no topo e definiremos o
alfa como zero. Basicamente, estamos criando
um gradiente aqui. Estamos dizendo que, desde o início, coloque branco no
final, ainda seja branco, mas no início tenha o alfa completo
e, no final, seja
completamente translúcido
16. 15. Criando um hub inicial: Para cá. E bem-vindo
de volta à Unity. Agora, neste episódio,
vamos criar um hub inicial para
nossa plataforma, um jogo. Também vamos dar
um nome a ele. Um nome que eu
escolhi é Sky Miner, que é horrível Mas, felizmente, esse jogo não será
lançado para ninguém É só para vocês
aprenderem a criar plataformas. Eu escolhi o Sky
Miner e vou criar um
hub inicial para este jogo Além de fazer com
que você não jogue o jogo
automaticamente.
No minuto em que clicamos em reproduzir. No momento, estamos entrando
direto no jogo. E eu não quero ser
assim. Eu quero que seja para que você possa escolher quando começar. Vou explicar como vou
fazer tudo isso, mas basicamente
vou construir como um hub inicial
no original, fazendo com que pareça muito dramático, é apenas uma grande nuvem. Eu também vou colocar o
título no topo. Então eu vou fazer com que
, no minuto em que você passar por um determinado ponto,
o jogo comece. Não no minuto em que você
começa o jogo, no minuto em que você passa
um certo ponto antes de eu me antecipar. Deixe-me prosseguir e importar
todos os meus ativos diferentes. Vou clicar com o botão direito do mouse. Importe um novo ativo,
como sempre. Em seguida, vou importar
esses dois ativos que
criei , chamados de
início e título. Vamos configurá-los para 12, ponto
único, sem filtro. E então eu realmente
vou para essa nuvem aqui. E vou
excluí-lo porque vou
substituí-lo. Também
vou usar essas
nuvens pré-fabricadas e
armazená-las porque não
gosto do fato elas estarem apenas
embaixo delas Isso parece muito
legal, na minha opinião. Então eu vou arrastar
essa nuvem inicial para dentro. Você pode ver como é. Isso é o que eu imaginei
para o início do jogo. Você começa com esse enorme, obviamente não desse jeito,
tem que estar lá. Você começa com uma grande nuvem
no meio e, na verdade,
vou movê-la para baixo Não queremos
ocupar muito
da tela, mas também não
queremos muito pouco. Acho que isso
provavelmente é bom. Eu posso ajustar isso à medida que prossigo, mas na verdade acho que vou
aumentar um pouco mais. Na verdade, vamos ver. Obviamente, podemos mudar
isso à medida que avançamos, mas acho que é realmente
muito bom começar agora. Vou colocar o
título no meio
da tela para poder ver
tudo o que está acontecendo. Vou clicar nesses ícones. Posso esconder todas essas coisas extras, mas também posso optar por
mover algumas dessas nuvens agora que estou criando
essa nova área central, mas falarei sobre isso mais tarde. Primeiro, deixe-me
desativar essas nuvens. Também vou
arrastar meu título, e você pode ver meu título
ali no meio
da tela. Acho que é um
título um tanto decente. Pelo menos por enquanto. Na verdade, vou
desativá-los só porque ocultá-los só
funciona no editor e quero vê-los
no meio da tela. Em seguida,
vou ver meu título, que na verdade vou
querer manter como sprite Eu não quero ser um objeto de interface de usuário, centralizá-lo em zero e depois
colocá-lo no topo aqui. Por
enquanto,
também vou desativar essa
interface de usuário porque também não
quero que ela apareça no
início do meu jogo. Obviamente, vou consertar tudo isso quando for
criar meu jogo. Mas tenha paciência
comigo a partir de um minuto. Primeiro de tudo, eu vou
ter isso aqui. Mineiro celeste. Na verdade, a primeira coisa que
vou querer
fazer é criar uma animação de título. Vamos criar uma nova animação. Vou chamá-lo de
título então. Eu só vou fazer isso subir e descer
lentamente. Vamos mover os primeiros
30 segundos,
digamos, de 2,6 para
2,4. Você vai assim, e então eu quero
ficar em 2,4 e descer um pouco nos próximos
30 segundos até talvez 2,3. Então vamos, então queremos voltar
para 2,4 um pouco mais rápido. Então, voltemos ao que
originalmente tínhamos aqui, que era, eu acho, 2.6 Sim. Vamos ver como isso parece. Veja se estamos indo para o jogo
um pouco rápido, mas acho que
dá conta do recado. Parece bonito. Tudo bem, como uma animação em
loop sutil, vamos fazer essa velocidade de 0,3 Vamos ver se clicamos em
play o que parece. Então, teremos que ver
a câmera se
mover e morreremos em Son, porque não
há coisas. Mas acho que isso faz
um trabalho muito bom. Está se movendo muito lentamente
pela coisa. Na verdade, isso me leva
à próxima coisa que quero fazer, que é começar a construir
essa área inicial, não apenas ter um quadrado. Vamos adicionar um box collider two D.
Obviamente, teremos que marcar isso como terra Vamos continuar e
verificar se essas são as dimensões corretas. Pode ser muito difícil ver isso se você tiver todas
as coisas que eu faço. Então, eu também vou desativar
o plano de fundo agora. Eu poderei
ver isso. Agora vamos passar isso para lá. Não
precisa ser muito mais alto aqui, porque você realmente não
deveria ser
capaz de cair. Isso deve ser tudo
feito lá. Agora vamos testar se
podemos jogar o jogo. Eu sempre desativei meu
plano de fundo no editor. Vai mostrar aqui
que parece muito bom. Na verdade, vou fazer
isso um pouco menor. Vou movê-lo
para mais ou menos lá. Isso é basicamente o. Acabei perceber que isso vai
ser um pouco problemático. Vamos mover isso
um pouco e descer um pouco mais. Acho que isso provavelmente é bom agora você pode ficar no
final da nuvem, mas isso não é um
grande problema. Esse será o
básico para o meu ponto de partida
aqui. E eu tenho meu título que vai subir e
descer. O título. Na verdade, eu nunca quero me mudar. Eu quero mantê-lo
aqui o tempo todo. Não preciso fazer
nada com isso. O mesmo com a partida. Essas
são posições fixas. Mas o que eu quero fazer é fazer com que as coisas
sigam a câmera, como a interface do usuário, ou só ativadas depois de
analisarmos isso. E eu também só
quero começar o jogo. Depois de percorrermos
esse ponto imaginário aqui no
meio da partida, vou criar
um novo objeto vazio E vou
chamá-lo de limite, assim como fizemos antes Aqui nesta fronteira, eu vou fazer um colisor Vou fazer
dele um colisor de bordas porque será
um limite Vou fazer 0,0
0,5 e menos cinco, é um limite longo Vai ser um gatilho
e vai ser do tipo zona inicial. Em termos de tags, vou criar
a
zona inicial da tag e tenho esse
grande colisor de gatilhos E eu vou
dizer que quando o jogador passar por isso, eu
quero começar o jogo. Então, obviamente, você pode
ver que podemos seguir em frente. Na verdade, vou
prolongar um pouco mais, caso contrário poderá
falhar. Dependendo de quão
estranho isso pareça, posso fazer disso um colisor de caixas
e depois outro
colidir embaixo,
mas isso parece um pouco
mais trabalhoso e depois outro
colidir embaixo, , para uma pequena
mudança Mas agora tudo em que estamos focados é ter
esse limite. E queremos dizer,
ok, no minuto o jogador ultrapassa esse limite, então queremos começar o jogo Nós rotulamos essa
tag como zona inicial. Mas,
na verdade, vamos codificar essa coisa em si. Vamos dizer que quando eu
colidir com o jogador, não
vamos nos preocupar com
o jogador colidindo com ele Isso é só uma formalidade. Vou reativar o
armazenamento para poder ver tudo o que tenho e começar a personalizá-lo Eu realmente não quero mais aquela
nuvem lá. Eu realmente não quero
essa nuvem aqui. Opa, eu não pretendia excluir toda
a interface do usuário. Na verdade, não quero
essa nuvem ou essa nuvem aqui, porque nosso jogo parece
bom só com o céu. Como agora adicionamos
outras coisas, eu nem
quero realmente essa nuvem. Mas vou colocar essa
nuvem aqui só para ter algo para onde
ir quando o jogo começar. Mova essa nuvem um pouco
para cá. Temos uma nuvem
para começar. Essa será a aparência do
jogo quando você começar. Obviamente, depois de
ultrapassar esse ponto, queremos que o jogo comece. Vamos continuar
escrevendo um novo roteiro chamaremos de Start Game. A forma como o script
vai funcionar é que vamos substituir muitos desses inícios vazios que
temos , que começam quando
o jogo começa Vamos chamar de dois vazios. Os únicos com os quais
realmente nos
preocuparemos são o script de movimento da câmera e
o script de geração do mapa. Se formos até aqui, podemos
ver os movimentos da câmera aqui. Vamos
querer nos preocupar com isso e
também com esse script de
geração de mapas aqui. Esses são os dois
que você pode ver aqui. Temos que gerar uma peça, mas queremos
mudar isso para começar o jogo e vamos
tornar isso um vazio público Na verdade, nem
precisamos anular isso. Poderíamos simplesmente nos
afastar e criar um mapa. Mas, por convenção,
quero que seja essa coisa
aqui em que só começamos quando
chamamos esse jogo de vazio Essa anulação de atualização realmente
não será um problema porque não
vamos mover a câmera, então também não precisamos nos
preocupar em gerar mais peças do mapa Vamos voltar ao meu
jogo e criar uma colisão no evento de gatilho No gatilho, insira duas etiquetas de comparação de pontos do
objeto de jogo de colisão D. Assim como fizemos o tempo
todo, é jogador. Em outras palavras, se o
jogador acabou de entrar em nós, queremos
começar o jogo. Vamos criar uma
referência para esses dois scripts. Movimento da câmera, vamos
chamá-lo de movimento da câmera. criaremos
uma referência ao nosso script de geração
de mapas. Chame isso de mapa. O que
faremos é dizer que o mapa começa o jogo. Em outras palavras, comece o jogo. Vamos dizer câmera, movimento
da câmera. A
velocidade da câmera é igual E então
teremos esse valor padrão aqui em nosso movimento de câmera, que será o que
queremos que seja a velocidade. Na verdade, vou
mudar isso. Vou fazer com que esse
público flutue a velocidade da câmera. Então teremos um carro alegórico
público embaixo dele, que vou chamar A velocidade aqui, eu vou definir como a variável
que a está movendo. E então a velocidade da câmera
é como essa configuração que
eu quero, vou definir
isso no jogo, mas ela só vai
ser influenciada pela velocidade. E eu vou
dizer que a velocidade da câmera é igual à velocidade da câmera. Em outras palavras, eu tenho
essa configuração aqui, movimento
da câmera, velocidade da câmera, eu tenho a configuração aqui, que me diz o quão rápido
eu deveria estar me movendo. Então eu tenho a variável de
velocidade, que obviamente vai
começar em zero. Então, no minuto em que eu começo
meu jogo e digo, ok, ajuste a velocidade para
a velocidade da câmera, então ela
mudará para o que eu
coloquei aqui e eu vou começar
a nos mover. Esse é praticamente todo o
código que realmente precisamos para iniciar nosso jogo manualmente. A maneira como podemos testar é que podemos entrar em nosso limite aqui Então, vamos prosseguir e
começar o jogo. Em seguida, arraste nosso script de movimentação de
câmera de nossa câmera e nosso
script de geração de mapas de nossa câmera. que possamos ver no
minuto em que toco em um player, devo iniciar esse código.
Eu deveria começar a me mudar. Vamos voltar para minha câmera principal. Vamos ajustar a velocidade da minha câmera para
um ponto. Minha velocidade é zero. Agora, jogue com sucesso.
Eu não deveria começar o jogo até que eu
prossiga até lá. Vamos
ver se isso funciona. Atualmente em movimento,
nada apareceu ainda. Obviamente, as nuvens ainda
estão surgindo, o que eu quero, mas
nada mais aconteceu. Mas no minuto em que eu cruzo
essa fronteira aqui, o jogo começa.
Veja aqui. Agora eu posso realmente começar
a jogar o jogo, que é
exatamente o que eu quero. Obviamente, essa primeira nuvem
é um pouco estranha, porque aparece em
cima de outra Talvez eu tenha
que ajustar esse deslocamento inicial e
fazê-lo começar um pouco mais adiante, mas acho que seria bom Podemos mudar isso um pouco. Vamos nos concentrar
em mover isso. Talvez você nem precise migrar
para a primeira nuvem, é só uma nuvem
para outra nuvem. Então, a primeira nuvem
deve aparecer acima dela, então
ficará muito melhor Agora, isso realmente
funcionou perfeitamente bem. Vou mover esse limite um pouco para
o lado daqui No minuto em que você passa por uma determinada
coisa, ela realmente desaparece. Mas há mais duas
coisas que eu quero fazer. Primeiro de tudo, quero
ter certeza de que esta placa exiba sua
escola secundária de diamantes Na verdade, isso também
é muito fácil de fazer. Tudo que você precisa fazer
é acessar minha interface de usuário e
criar um novo texto aqui. Vamos usar o Legacy Text, porque não queremos
usar o texto para mim. Vamos chamar isso de diamantes.
Vou movê-lo para cá. Na verdade, por uma questão de
simplicidade, vou copiar esse contador de diamantes que
tenho aqui E mova-o para cá. Em seguida, vou definir um valor de
teste de 300 ou mais. Não parece que
nada apareça. Vamos tentar
redimensioná-lo. Está por trás disso. Na verdade, vou
ter que mudar a ordem dessa tela. Vou fazer a ordem da
tela na camada
dois em vez de uma
ou até cinco, porque praticamente queremos a tela
na frente de tudo. Então, deixe-me fazer dez, para ver se isso resolveu nosso problema. Se voltarmos aqui. Sim,
agora podemos ver que temos isso aparecendo na frente,
que é exatamente o que queremos. Vou girar um pouco porque
a placa está um
pouco torta Vou redimensioná-lo de volta para o que deveria ser, que era
algo mais parecido Vou definir isso para isso. Vou
girá-lo um pouco mais. Acho que isso provavelmente é bom. Pode ter girado um pouco demais. Vamos voltar um pouco atrás. Agora podemos ver que temos
um pequeno marcador que
nos mostra qual foi o máximo de diamantes coletados em uma das corridas Agora, obviamente, precisamos programar isso para realmente
exibir a pontuação mais alta. Na verdade, isso é incrivelmente fácil. Tudo o que precisamos fazer é que realmente não importa
qual roteiro escolhemos. Podemos escolher qualquer um,
mas vou
escolher esse
script de diamante para jogadores aqui. Porque isso já
tem a interface do usuário aqui e já tem uma
referência ao objeto de texto. Vamos criar um novo,
texto público, chamado de ensino médio. Então, tudo que eu preciso fazer sob
o vazio inicial é dizer que texto com pontos do
ensino médio é igual aos diamantes do ensino médio com dois
pontos Basicamente, isso vai dizer que, quando eu começar o jogo, certifique-se de definir esse
texto ou qualquer que seja minha melhor pontuação.
Se voltarmos ao meu jogo, agora vamos até meu jogador e ver
se isso funciona. Vamos descobrir aqui que
temos ensino médio. Coloque-o neste contador. Vou renomear isso
para contagem de pontuação alta. Então, se tivéssemos que jogar,
deveríamos ignorar isso. No início do jogo
com nosso ensino médio, o que parece que aconteceu, nosso ensino médio não deveria
ser zero, deveria ser um. Parece que temos um pequeno bug, mas acredito que,
na verdade, o único
problema é o
fato de estarmos atribuindo isso antes Atribuímos a variável
aqui , que é
exatamente o que é. Vamos voltar aqui
e colocá-lo embaixo. E então deve
funcionar perfeitamente bem. Se voltarmos ao nosso jogo,
clicamos em jogar. Devemos ver, agora isso deve mudar para um no minuto em que
começamos o jogo. E parece que
é. Isso é perfeito. Agora temos um balcão do
ensino médio. Temos uma coisa que
nos permite começar o jogo
percorrendo ele. E temos todo o resto
funcionando como deveria, o que é muito legal. Tudo o que precisamos fazer agora, a última
coisa que realmente
precisamos garantir é
garantir que, quando
começarmos de novo, isso não nos cause falhas O que eu realmente
vou fazer em vez de mover essa nuvem
é fazer com
que a primeira nuvem apareça um
pouco mais adiante E então eu vou fazer
isso, vou
entrar no meu script de geração de mapas. Vou ter lingotes
aqui para ser o bloco de partida. Em outras palavras, se for
o primeiro, vou definir
como falso aqui, mas aqui
sempre precisa ser verdadeiro o primeiro bloco. E isso
basicamente nos permite, quando chamamos esse objeto, chamamos esse método, podemos inserir um valor aqui
quando o chamamos daqui,
podemos diferenciá-lo de
onde o chamamos daqui Então, tudo o que precisamos
fazer é adicionar uma pequena declaração
if no final. Precisamos dizer começando. Em outras palavras, se houver
o primeiro
, eu só quero movê-lo
um pouco para o lado. Eu vou dizer que vi um
bloco gerado, uma oposição transferida. Vamos adicionar um deslocamento inicial. Então, vamos começar com o
offset do carro alegórico público e
vamos torná-lo um pouco maior do que o
que temos aqui Basta colocar isso ali. E basicamente
vamos dizer,
ok, vamos colocar o ladrilho lá. Mas se for o primeiro ladrilho, eu realmente quero
colocá-lo em outro lugar. Então, deixe-me colocá-lo lá. Ele vai gerá-lo
em um lugar diferente, mas isso realmente não
faz diferença Vamos voltar aqui e voltar para
nossa câmera principal. E vamos fazer o
deslocamento inicial 18 em vez de 15
e ver se isso funciona Agora movemos isso um pouco, vamos ver se isso funciona um
pouco melhor em termos de espaçamento. Vamos então testar
esse molde duradouro, que foi ver se o resto
do jogo funciona sem problemas. Parece que 18 está realmente
funcionando muito bem. Temos um problema
aqui com o que você precisa corrigir,
ele não vai desaparecer. Na verdade, também temos
um problema com a interface, que eu também quero corrigir
para que ele não permaneça quando você
não estiver jogando. Mas vamos primeiro
testar a outra coisa,
morrer, depois a câmera ainda se move. Esse é outro problema
que precisamos resolver. Vamos voltar e tudo
parece estar funcionando bem. Vamos dar uma olhada rápida no que
temos que corrigir. Em primeiro lugar, a
razão pela qual a câmera ainda está em movimento é porque esse script
original aqui, que editou a
velocidade da câmera quando você morre, alterou a variável de
velocidade da câmera. Queremos alterar
a variável de velocidade porque mudamos a
forma como esse script funciona. Então, queremos fazer com
que mude a velocidade, não a velocidade da câmera.
Essa é a primeira coisa. A segunda coisa que queremos
fazer é garantir que esse
texto aqui que temos
não continue se movendo enquanto
a câmera se move. A maneira como vou fazer isso é criar
uma nova interface de usuário e armazená-la lá e
fazer com que ela não se mova. E depois tenho essa
interface de usuário que eu possa editar e usar quando
quiser começar o jogo Já fizemos
muitos episódios, sei que já faz um tempo,
mas estamos quase terminando. Então, tenha paciência comigo enquanto
terminamos essas duas últimas coisas. primeira
coisa que vou
fazer é
ir até o início e
criar uma nova tela. Vou chamar esses dois. Em seguida, vou copiar minha conta do
ensino médio e colocá-la em
duas, em vez de
onde estava originalmente. E vou
mudar a interface do usuário dois para a tela da câmera
espacial e
arrastar minha câmera, depois clicar duas vezes nela
e ver onde ela está, não onde deveria estar, mas
vamos movê-la de volta para cima. Vamos alterar
essa ordem e camada para dez também, assim
como a outra. Então vamos movê-lo para lá. Acho que era mais
ou menos onde estava. Obviamente, podemos
ajustá-lo à medida que jogamos, mas acho que isso é
muito bom por enquanto. Então, na verdade, uma vez que
eu tenha orientado isso, vou voltar
e vou mudar isso para o espaço mundial. Em outras palavras, ele não vai
se mover com a câmera. Depois de
posicioná-lo perfeitamente, isso deve
funcionar perfeitamente E agora temos essa interface de usuário que não vai se mover
com o resto do mundo. Então, se agora clicarmos em play e vermos se isso funciona, essa interface de usuário
permanecerá exatamente onde está. E à medida que avançamos, ela não nos segue,
o que é perfeito. Obviamente, essa interface de usuário ainda está aqui, o que é um
pouco problemático. Vamos fazer com que essa interface seja ativada
apenas. No minuto em que
pousarmos nessa posição
inicial aqui, teremos
uma pequena animação
para que fique
um pouco melhor. Vamos ver a animação da janela. Vá até o meu U aqui e
vamos criar duas animações. Na verdade, vamos
à animação de ativos. E o primeiro será
um desvanecimento na animação. Então, a segunda animação
que teremos será
o que chamaremos
de animação estática. E isso só
vai dizer, ok, mantenha as posições
exatamente onde elas estão. Vamos colocar os corações nesta
posição aqui, 498,5 E vamos colocar o diamante
nesta posição aqui, 52,94 59,8, desculpe Hum, e esses agora devem indicar,
agora, se jogarmos como
animação, funciona. Vamos ver como minha
animação desbotada funciona. Eu quero que isso vá daqui para
lá por cerca de 2 segundos. Eu quero que ele desapareça até
onde estava, que é a posição 400 E qual era a posição? Acho que foi 459. Vamos ver nossa outra
animação só para vê-la. 502,9 para os diamantes, e depois Vamos copiar a posição desses
corações. Volte aqui
e depois aqui. Neste ponto, quero que os
corações estejam nessa posição. Vamos mudar para 459,8 E então eu quero fazer exatamente
a mesma coisa, com o diamante saindo daqui Então, 2 segundos depois, eu
quero
que esteja na outra posição, então vamos pegar
52,9 aqui Neste momento, quero que os
diamantes também estejam lá. Veja, agora eles
vão desaparecer assim, e então o jogo
vai começar Tudo o que precisamos fazer,
precisamos, certo? Ah, vamos também fazer mais
uma animação em que eles estejam fora de vista. Vamos criar um novo e
vamos chamá-lo de fora de vista. Na verdade, isso
vai ser quando esses dois estiverem meio que fora
da tela. Realmente não importa onde eles estejam, desde que sejam atingidos. E também poderíamos fazer com que eles fossem realmente desativados Mas vou fazer assim por enquanto, porque
isso torna um pouco mais fáceis, já que estamos apenas mudando suas posições. Na verdade, essa
será a animação padrão. Vamos começar
com isso ou com coisas fora de vista. Vamos
abrir a interface do usuário. Vamos definir isso para
o estado padrão. Então, queremos ter
certeza de que, no minuto em que
desaparecermos, vamos
direto para a estática Vamos fazer a
transição aqui. Isso vai nos apresentar um novo conceito que é como transições
automáticas Vamos definir
esses dois para zero, mas depois vamos
manter, isso, horário de saída
mudou. Isso significa que, no
minuto em que isso for feito, mudar para estático
e o tempo de saída zero significará que ela
concluirá a animação
e depois se moverá para cá. O que vai
ficar bem legal. Agora, tudo o que precisamos fazer é ter um gatilho, que também é um novo
tipo de parâmetro. É muito semelhante a um booleano. Pense nisso como um botão
em vez de uma alavanca. Vamos apenas
chamá-lo de start. Vamos até
aqui e
vamos fazer essa condição de
transição. Comece com zero, certifique-se de que não haja
tempo extra e a duração da transição também seja zero. Basicamente, isso
vai funcionar de forma que, no minuto em que clicarmos aqui, ele apareça
e fique lá Isso é tudo o que precisamos
codificar para garantir que nossa interface de usuário não inicie
quando iniciamos o jogo. Agora precisamos adicionar mais
um parâmetro aqui
ao nosso código
inicial do jogo. Vou criar um animador
público, que será nosso anum Então, vamos ver aqui
embaixo e dizer que eu posso acionar o gatilho, acho que o chamamos Agora, essas três coisas juntas basicamente
nos
permitirão iniciar o jogo
manualmente a partir desse evento. E este aqui fará com que possamos
garantir que nossa interface de usuário só comece
quando iniciarmos o jogo. Vamos voltar ao
meu roteiro inicial. Por aqui, limite,
estava aqui. Vamos arrastar esse animador de interface e ver se tudo funciona
exatamente como precisávamos Vamos jogar e vamos ver. Começamos com a interface fora da tela, exatamente como uma ou duas. Começamos com a pontuação
de um, nada mais. No minuto em que eu começo este jogo, podemos ver minha interface de usuário desaparecer E isso
realmente parece muito, muito legal. Agora eu posso começar a jogar
meu jogo normalmente. Essa é a última grande
mudança quando você faz com que nossos jogos ainda precisem
adicionar áudio e som. Sei que digo isso
praticamente em todos os episódios, mas acho que essa é
uma mudança muito legal que
fizemos em nosso jogo até agora. E fizemos com que
ficasse muito mais bonito, especialmente com
os visuais extras E agora com todas
essas outras coisas. E agora também
temos que começar em hubs. Então, se
morrermos e
perdermos o jogo, vemos tudo desaparecer, então vamos começar de novo e
começar de novo, assim como estávamos
com uma nova pontuação máxima porque ganhamos muito
mais moedas dessa vez, o
que é muito, muito legal Então, isso é tudo
para esse episódio. Obviamente, adicionaremos
nosso áudio e música no próximo episódio, e então devemos
fazer alguns
retoques finais e
terminar nosso jogo Então, você quase
concluiu todo o curso, que é um trabalho muito
bom e excelente se você
conseguiu
acompanhar tudo até agora e seu jogo se parece com o meu. Se você tem algumas coisas
diferentes, talvez volte e assista a
alguns vídeos e baixe os recursos para ver onde os
seus são diferentes dos meus. Porque você deve
ser capaz de criar meu jogo exato basicamente usando os arquivos e o recesso que eu forneço em todos os vídeos Portanto, certifique-se de que você
tenha tudo igual. E eu até anexei meu código ,
caso você queira
verificar isso também. Então, espero que você
tenha seu jogo exatamente
no mesmo estado em
que o meu está agora E você conseguiu
acompanhar tudo neste vídeo. Ótimo trabalho em chegar até aqui. E vamos
começar a adicionar áudio e música
no próximo episódio. Obrigado.
17. 16. Adicionando efeitos sonoros e música: Olá, e bem-vindo de
volta à Unity. Agora
chegou a hora de nosso jogo finalmente
adicionar um áudio, porque apesar de termos
feito praticamente todo
o resto, nosso jogo ainda está
totalmente silencioso. Adicionar um áudio é apenas uma das outras
coisas que fazem com que seu jogo pareça muito mais responsivo e vivo
para o jogador Para adicionar um áudio, vamos seguir um processo bem
simples. Primeiro,
criaremos um novo objeto chamado Gerenciador de áudio, onde
acompanharemos todo o áudio central,
coisas como se o
áudio está ativado
ou desativado e
o que reproduzir e quando. Em seguida, editaremos
todos os nossos scripts e diremos que tocaremos
um som neste momento. Para começar, vamos
criar um novo objeto, chamado de Gerenciador de áudio. Vou
defini-lo como zero por nenhum motivo além da preferência. Em seguida, vou criar um
novo script e
dar a ele o mesmo
nome de gerenciador de áudio. Então, dentro do script do meu
gerenciador de áudio, terei uma referência a cada fonte de áudio, que é de onde
vamos reproduzir o
áudio no jogo. E então haverá vazios diferentes para cada um que dirá jogue isso,
jogue isso, jogue isso, etc Na verdade, vou
simplificar isso. Eu vou ter um vazio e vou dizer toque o som Mas estou me adiantando. Deixe-me primeiro escrever
uma fonte de áudio pública. Vou ter que
criar um desses para cada
arquivo de áudio que eu tiver. Agora, antes de criar isso, deixe-me primeiro
importar meus arquivos de áudio. Vou criar uma nova
pasta, chamá-la de áudio, e dentro dela,
vou querer colocar
cada um deles, acho que existem sete arquivos de
áudio que tenho até agora. Então, vamos
importar tudo isso. Eu tenho todos eles aqui e vou deixar todas
essas configurações por enquanto. Esses são basicamente um
monte de arquivos de áudio. Isso é para coletar diamantes, isso é para as baterias Faça um Zap. Som Isso
pode ser um jogo de sons. Isso é causar dano,
som, salto, a música do jogo e também efeitos sonoros
para o robô. Vou abordar tudo isso agora,
mas, por enquanto,
deixe-me adicionar uma fonte de áudio
ou, na verdade, adicionarei sete fontes de áudio a esse script do gerenciador de áudio
e, em seguida, criarei
uma referência para todos. Então, deixe-me
digitar a fonte de áudio. Vou adicionar sete
desses, sete aqui. E o minerador
que fiz isso, agora vou
começar basicamente a
mixar meu áudio Então, deixe-me ir em frente e
desativar tudo isso. E todos esses
sons são diferentes e alguns
deles são muito
mais altos do que eu gostaria que fossem Agora, devido ao
software de gravação que estou usando, talvez
você não consiga
ouvir o áudio do meu jogo vindo
diretamente do vídeo. Se for esse o caso,
então você só
quer , obviamente,
acompanhar o processo. visualização será exatamente a mesma
e você só quer ajustar o volume de cada clipe
de áudio adicionado ao jogo. Então, deixe-me começar
com a música. Vou arrastar o clipe
para essa propriedade do clipe de áudio. Vou definir play a wake true e loop true
para a música. E agora eu só quero
mudar esse volume. Eu já posso dizer que um
vai estar muito alto, então deixe-me tentar 0,2 primeiro e ver como
preciso ajustá-lo. Acho que 0.1 é um pouco melhor, só por isso é mais parecido com música de
fundo Vamos definir que 0,15 provavelmente
seja um bom meio termo, então eu vou
fazer exatamente a mesma coisa com cada um deles Em vez de alterá-lo, vou simplesmente silenciar
o que está acima dele e, em seguida, fazer o som do salto tocar
em um wake and loop Então, eu também posso obter um bom
volume para isso. Obviamente, isso é
um pouco alto demais. Vamos fazer com que 0,20 0,2 ainda
seja muito alto. 0,10 0,05 Acho que 0,1 provavelmente é
um bom meio termo Vamos fazer com que seja 0.1. Vou repetir esse processo indefinidamente até que tenhamos feito
tudo isso. Então, vou basicamente
desativar todos esses,
que não quero que sejam ativados que não quero que sejam Se você estiver acompanhando
há muito tempo,
espero que tenha áudios semelhantes
aos meus. Achei que Obviamente, você pode
ajustá-los para o seu jogo. Posso alterá-los à medida que avança, mas é assim que vou mixar todo o meu áudio e
, em seguida, vou desmarcar a opção
Reproduzir ao acordar para praticamente todos
, bem como silenciar e repetir, porque não
quero que nenhum
deles seja reproduzido ou
reproduzido em loop deles seja reproduzido ou
reproduzido Realmente a mesma coisa com o sucesso, exemplo, eu não quero que
o fim do jogo
seja nenhuma dessas
coisas, nem o robô. E então eu vou
configurar a mesma coisa para pular aqui, que nós vamos
acionar também. A música, eu vou
continuar tocando acordado e
continuando só porque você obviamente
quer tocar a
música quando ela estiver ligada Agora, antes de prosseguir, vou
começar adicionando um coque mudo e um som desligado O que basicamente os
programará para dizer, ok, desative tudo isso
e salve tudo isso. A maneira de fazer
isso é
criar uma matriz de fontes
de áudio públicas. Esse será
o efeito sonoro para criar outra fonte de áudio
pública. E essa vai ser
para a música. Então eu vou
criar alguns vazios. O primeiro vazio será um vazio musical mudo,
que deixará a
música muda que deixará a Igual ao verdadeiro. Na verdade, eu poderia criar outro vazio aqui que diz não Música Mas, na verdade, eu os
combino em um vazio. Vou chamar isso de divertido, mudo. Silenciar. Música Vai
ter um lingote aqui, que
será chamado de mudo Originalmente, será definido como falso. Então, vou
definir mudo igual a mudo. Em outras palavras, mude
o que foi silenciado. E eu vou colocar isso
aqui como mudo também. Não silenciado. A primeira
vez que eu clicar aqui, vai dizer,
ok, silenciar é falso Defina mudo para não
silenciado, o que é verdade. E então defina como mudo igual a
não silenciado, silenciado é falso. Portanto, defina mudo como verdadeiro. Então, na segunda vez,
vai dizer definir mudo para não mudo, mudo,
não é verdade Então, vai ser definido como falso. Basicamente, isso vai se
alternar toda
vez que ligarmos para ele. Vou escrever exatamente
o mesmo vazio
para os efeitos sonoros, efeitos sonoros mudos e mudos Vamos escrever
para cada fonte de áudio pois eu tenho que digitá-la assim, porque as é uma palavra
reservada em SFX Em outras palavras,
cada fonte de áudio que
vamos
atribuir a esse objeto
S, S é a primeira, pode
ser a primeira, depois a segunda para
cada uma aqui. Isso é conhecido
como quatro loops. Na verdade, é um para cada loop, mas você pode pensar neles
como uma repetição de código O. Isso quer dizer que para
cada S ele foi escrito um pouco para
nós, mas pense nisso como se fosse para
cada fonte de áudio
dentro dessa coisa Defina o valor de mudo igual
a não ser o
que é meu mudo. Para SX, isso é silenciado. Música Isso será
silenciado, SFX. Deixe-me mudar isso rapidamente então. Basta copiar isso
aqui, aqui. Eu vou dizer FX silenciado. Em outras palavras, atualize cada coisa,
para que seja a mesma coisa. Em seguida, defina o SFX mudo para
o que não era antes. Em outras palavras,
este código
alternado aqui nos
permitirá ativar ou desativar todas as fontes de áudio que
temos em nosso jogo Agora precisamos escrever códigos para reproduzir as fontes
de áudio específicas, mas vou combinar
isso em um vazio Vou chamar isso de vazio
público, chamá-lo de play. Som Como entrada, vamos basicamente
inserir uma fonte de áudio. Vamos
inserir a fonte de áudio , pois todo o vazio
será reproduzido Em outras palavras,
vamos tocar uma fonte de áudio que
estamos escolhendo aqui. Então eu vou
chamar isso de vazio. Vou criar
uma referência para esse script de gerenciador de áudio em vários outros scripts em
que preciso chamar voids Chame isso de vazio especificamente e eu vou transmitir
o som que eu quero Vamos começar
preenchendo todos os sons. Em primeiro lugar, temos nosso game over Sound, bem como
nossos sons de dano. Vamos falar sobre a Saúde do Jogador. Vamos criar uma referência ao meu gerenciador de áudio.
Vamos chamá-lo de AM. Então, aqui dentro do
meu vazio de dano aqui eu vou
escrever AM Fx Agora eu preciso escolher qualquer
índice que eu vou ter. Deixe-me começar a
atribuir os índices a isso. Antes de fazer o
resto aqui, vamos arrastar meu script do gerenciador de áudio
até a parte inferior aqui. Eu apenas minimizo tudo isso porque não preciso mais
editar as configurações. Agora vou ter a fonte
Music This aqui e todas as outras fontes. Deveria haver outras
seis fontes que
vou
inserir desta forma. E você pode ver que, na verdade, está nos
causando um pequeno problema. Agora temos esses
que não estão aqui. Então, vou excluir
aqueles clicando com o botão direito do mouse e dizendo excluir elemento de matriz. E então eu tenho minhas seis fontes
de áudio e depois salto, depois robô e fim de jogo. Em seguida, toque, depois elétrico
e, em seguida, colete
o diamante ao qual quero me referir aqui. Hit é o quarto. É o elemento três aqui. E você pode ver que
aqui, esse é o elemento três. Golpear. Vamos voltar ao meu código e digamos que sou o elemento três. E eu vou passar
isso para AM, Play Sound. Vamos em frente, vá assim. Basicamente, isso
vai dizer, ok, toque um som e toque qualquer fonte de áudio em que
você tenha armazenado. A terceira coisa, que
é a que acabamos de fazer, vou repetir esse
processo praticamente onde quer que tenhamos um som que queiramos
tocar, vamos até a morte. Em The Death One,
queremos acabar com o jogo. Sound Which é, então
acredite que é o penúltimo. Na verdade, é
o terceiro, eu acho. Sim, é o terceiro,
que é o elemento dois. Vamos até aqui e vamos
jogar o elemento dois aqui. Agora temos dois
deles resolvidos. Ainda precisamos adicionar
os sons de salto. Vamos ao roteiro do movimento. Acredito que esteja
aqui. Movimento do jogador. Vamos criar
outra referência ao meu gerenciador de áudio, chamada AM. Vamos até o meu vazio
e dizer AM Play. Som E agora temos que
encontrar o som do salto. Sinceramente, não consigo me lembrar
porque não os tenho
memorizado . Mas eu
quero dizer que é o primeiro. Sim, é o primeiro.
Vamos até aqui e vamos tocar o primeiro som. Agora, fizemos três deles. Só
faltam três. Obviamente, precisamos do som para
a eletricidade, assim
como do som
para o robô. E precisamos do som para
a coleção Diamond. Vamos ver a
coleção Diamond, One first. Teremos que,
neste evento aqui,
tocar os sons. Vamos colocar o gerenciador
de áudio público AM embaixo do sistema de partículas Vamos de manhã para tocar Sound. Eu acredito que Diamond Collect
é o último som. Vamos apenas confirmar. Sim, é. Esse é o elemento cinco aqui. Vamos lá e
joguemos o último. Agora temos mais dois sons. Temos o robô Sound,
que precisamos tocar sempre que houver um robô nas telas
que seja um pouco diferente. Na verdade, isso vai
ser um pouco mais complicado. Então, vou mudar
o que estou fazendo aqui. Em vez de fazer com que
esse som faça parte da matriz na qual eu necessariamente vou
me concentrar, vou fazer com que o som seja
reproduzido acordado e reproduzido em loop Mas, em vez disso, vou
silenciá-lo. E então, sempre que eu tiver
um robô surgindo, vou me
certificar configurar essa coisa para
que fique silenciada E toda vez que eu tenho
um robô que morre, eu vou configurá-lo para que
ele não fique mais mudo Isso
funcionará na maior
parte do tempo que eles podem nos dar. Se houver um robô que
desova e depois morre enquanto
outro ainda está na tela Pode ser um
robô sem som, mas,
por enquanto será uma solução
praticamente perfeita Vamos até o
meu vazio aqui. Vamos ver no meu script, quando eu começar como robô, vou querer
configurar minha fonte de áudio, que vou criar
uma referência para o gerenciador
de áudio. Novamente, M aqui, eu vou apenas dizer AM de X. Vou me referir a ele como
o primeiro elemento Acredito que seja
o segundo, mas é o elemento
um na matriz. Mudo é igual a falso. Em outras palavras, jogue com o robô. Som Então, no minuto em que
esse robô morrer, no minuto em que ele não
existe mais na tela, vamos querer definir
esse mudo como verdadeiro novamente. A maneira como eles vão
fazer isso é, na verdade,
editando o script
que está acima do, que diz o que excluir. Vamos abordar esse
script
aqui , chamado Tile clear. Esse é o script
que vai
destruir as peças.
Chegou o minuto. Vou adicionar uma nova variável, chamada de robô, a bordo. E vai
ser do tipo lingote. Então aqui, quando eu
destruir meu objeto de jogo, vou adicionar outra
linha logo abaixo E vou dizer que se
um robô estava a bordo
, quero ter certeza de que meu gerenciador de áudio não está
mais reproduzindo um som. Não vou criar uma referência como eu
não conheço aqui. Vou usar o Game Object Find Audio Manager porque
será
muito mais fácil para um componente Get
pré-fabricado Em seguida, vou encontrar um script
de gerenciamento de áudio
anexado a ele. Eu vou dizer X, anexar o elemento dois ou
foi o elemento um? Eu acredito que pode
ter sido o elemento um. Na verdade, sim,
era mudo é igual a verdade. Tudo o que preciso fazer
neste script
de robô aqui é, no minuto em que eu o silencio,
preciso anexar, ir até meus objetos principais e
transformar os objetos principais Então eu vou
dizer que limpe o
bloco do componente e eu
vou dizer que o robô a
bordo é igual Essa pode ser uma maneira
um pouco estranha de fazer isso, honestamente, se você realmente
não quiser adicionar esse som de robô,
não é o fim do mundo Basicamente, o que estou fazendo
é dizer, ok, esse elemento específico
da matriz que ele
realmente não precisa na matriz. Só estou guardando isso
como lembrança. E eu estou dizendo, ok, mudo. Ele configura o mudo como falso
no minuto
em que eu apareço e me certifico de dizer meu ladrilho que há
um robô aqui,
e no minuto em que meu ladrilho
é destruído, se houver um robô lá, ele precisa garantir que
esse mudo esteja configurado como verdadeiro Na verdade, também poderíamos simplesmente
defini-lo como verdadeiro toda vez destruirmos um ladrilho que não
funcionaria
tão bem, porque então qualquer
ladrilho seria silenciado Os robôs aqui não existem
por um momento. Então, esperançosamente, isso sobreviverá durante a maior parte da vida útil
dos robôs E vai funcionar muito
bem por enquanto. Se voltarmos ao
meu gerenciador de áudio, eu já
programei meu roteiro musical e
terminei o salto, fiz o robô agora,
terminei o jogo e fiz o
sucesso também, mas a eletricidade. Parece que
eu também fiz o diamante. Vamos ao som da
eletricidade,
que estará no script da
bateria aqui. Vamos encontrar meu script de bateria, na
verdade está na loja Unity
, não foi aberto. Então vamos fazer essa
anulação da bateria aqui. Teremos uma
referência ao meu gerenciador de áudio. Novamente, também terei que
atribuir esse por meio de
código, porque
será um prefabs Eu vou dizer que M é igual ao objeto
do jogo dot find audio manager get component Agora vou encontrar um script de gerenciador
de áudio sobre isso. Vou me certificar de que
atribuí isso corretamente. E então tudo o que vou
fazer é dizer esse código exatamente como eu
disse em todos os outros, como Player Health
aqui, é aqui AM. Tocar som E então vou
escolher um elemento de matriz. Vou tocar o som
quando a bateria for ligada. Acredito que seja o quinto som. Deixe-me verificar se está seguro
, vamos jogar o elemento cinco. Agora, a forma como isso
vai funcionar é agora criamos
nosso gerenciador de áudio, que tem todos os
sons armazenados nele, bem
como o script, que esperançosamente nos permitirá
silenciar a música e não E ainda não
programamos isso Mas vamos
acrescentar isso no minuto em que tivermos todos os
sons funcionando. Então, espero que tenhamos
conseguido chamar cada som
de forma adequada de cada script, para que
possamos tocar
os sons quando precisarmos deles Vamos lembrar todos
os sons que
fizemos pela primeira vez . Música que não
tinha nenhuma programação. O salto foi referenciado
no
som do player . Vamos nos certificar de que atribuímos o gerenciador de áudio aqui Assim mesmo. Vamos voltar, vamos ver o que mais já
fizemos. O robô será
designado pelo robô. E, na verdade,
perceba que
não criamos uma referência a esse
script do gerenciador de áudio no Start. O que provavelmente deveríamos fazer porque este é outro pré-fabricado Então, vamos escrever exatamente o
mesmo código que escrevemos para a bateria dentro
desse outro prefab A razão pela qual estamos
fazendo isso para pré-fabricados é porque geralmente quando
temos objetos, podemos dizer,
ok, colocar isso nesse objeto, mas como esses objetos
ainda não foram criados, eles são como
robôs e inimigos Temos que escrever em
código para fazer isso por nós, porque não estamos lá para
arrastá-lo para dentro deles e no início
do jogo. É por isso que quatro,
alguns deles, tivemos que escrever
esse código aqui. De qualquer forma, esse deve ser
o código que precisamos para atribuir ao robô. Então, vamos
ver o que mais temos. O robô está pronto,
o salto está pronto, fim
do jogo e o golpe afetarão a saúde do jogador
, que está atribuída agora. Além disso, a coleta de
diamantes será em diamantes. E acho que diamantes, não me
lembro se nos lembramos atribuí-los por meio de código,
mas acho que não fizemos isso Então, vamos fazer exatamente a mesma
coisa que fizemos lá. Apenas certifique-se de
atribuí-lo por meio de código. Também fizemos isso
com a bateria. Isso significa que o
último que temos é apenas para o jogador que está
sofrendo danos e morrendo. Então, vamos para o Gerenciador de áudio, vá para o Player e
certifique-se de atribuir o script de integridade do player para ser esse
script do gerenciador de áudio aqui. Agora vamos continuar
e clicar em Player. Pode haver alguns problemas, mas vamos
corrigi-los ao longo do caminho. Mas espero que tenhamos feito tudo para
não ter nenhum bug E podemos ouvir a música e vamos tocar e ver
se tudo funciona. Parece que pular funciona. Temos nosso áudio,
temos o som de salto. Vamos testar
cada um deles.
Obviamente, vou
silenciar a música
só para poder ouvir todo o resto Não
parece que meu coração. O som parece estar funcionando com minha bateria. O som não parece
ser. Mas vamos testar. Obviamente, o coração está
funcionando, parece que acabou
meu jogo, o que é ótimo. Na verdade, é a maioria deles. Vamos ver quais ainda
restam. silenciar a música novamente, o salto
soa funcionando Tenho que testar o robô e o fim do jogo está
funcionando. Os sucessos estão funcionando. Eu tenho que testar a eletricidade. Parece que não está funcionando. Colecionador de diamantes, eu
ainda não testei. E acho que o robô também não está funcionando.
Vamos seguir em frente. Temos um erro
aqui que diz que referência do
objeto não está definida
para a instância de um objeto. Sim, parece que nosso
código não está funcionando exatamente. E acho que o motivo é aqui classificamos o gerenciador
de áudio de forma errada. Vamos seguir em frente
e corrigir isso. Colocamos um espaço lá
onde não deveria estar. Temos que ir. Acho que
escrevemos isso
nessas três linhas de código
aqui e também escrevemos
em tile clear. Vamos nos certificar de que devemos
acertar nessa hora. Certo. Vamos tentar isso
de novo. Vejo que todos esses erros estavam tentando reproduzir sons
, mas não conseguiram
porque não conseguiram encontrar
um objeto gerenciador de áudio com um espaço que fizesse todo
o sentido. Vamos tentar novamente.
Vou diminuir um pouco
o salto
porque está muito alto. Vamos tentar isso de
novo. Vou silenciar a música novamente para poder
ouvir tudo Vamos ver, Jumping
parece estar funcionando. Nós temos um diamante. Parece que o Diamond
Sound está tocando aqui. Pelo menos alguma coisa está tocando, mas temos o som
errado tocando. Vamos apenas testar. Cometemos
outros erros. O som do diamante
está tocando quando também
coletamos um diamante. interessante que
provavelmente É interessante que
provavelmente
o
tenhamos atribuído de forma errada na matriz, mas vamos tentar isso. O robô Sound também está
funcionando, o que é ótimo. Vamos voltar para minha matriz.
Vamos até aqui. Electricity Sound deve
ser o quinto. Vamos arrastar
isso para dentro e ver porque não acho que
tenha sido atribuído corretamente, esse
provavelmente foi o problema. Vamos até minha
bateria e verificar se estamos ligando para a coisa certa e
se estamos ligando para o elemento cinco, na verdade
estamos ligando para
as pessoas erradas. Vamos mudar isso para quatro. Temos mais um erro aqui que diz que a
referência de objeto não está definida para a instância de um objeto e diz
que o robô de script se move. Vamos ver qual é
exatamente o problema aqui, encontrar um gerenciador de áudio que possamos fazer
esse código funcionar também. Parece que o
problema pode estar
aqui com este bloco de obtenção de
componentes limpo. Obviamente, todos os nossos blocos devem ter aquele
script ali garante
que eles
se excluam quando
atingirem uma certa altura. Eu fiz alguns novos azulejos novos. Em algum momento, eu poderia
ter ido adicioná-los. Vamos garantir que
não esteja em todos os meus ladrilhos. Vamos verificar
quais não o têm. Todos fazem, todos
fazem o que um faz,
aquele não faz. Então, esses dois não
têm azulejos transparentes. Vá em frente e acrescente isso a eles. Não precisamos definir
nada, obviamente. E depois para o resto deles. Sim, eles têm, são
só esses dois. Agora, se voltarmos
ao jogo, tudo deve estar
funcionando muito bem e todos os nossos sons e
tudo devem estar ótimos. Vá em frente e aperte
play e veja se tudo funciona perfeitamente. Então, temos minha música tocando. No minuto em que começo a tocar
tudo, parece que os sons também
funcionam Parece que há uma pequena falha em
que dois desovam completamente um em cima do outro .
Claro o que é isso. Mas parece legal. Opa. Você pode ouvir
tudo o que está acontecendo, você pode ouvir o
zumbido, e você pode ouvir o robô de forma ainda mais maliciosa Obviamente, se você morrer, tudo
começa de novo, o que é muito legal. Essa é
praticamente toda a
configuração de áudio que precisamos
fazer para o nosso jogo. A última coisa é que agora
precisamos adicionar algo que nos permita
silenciar o áudio e o som, porque codificamos isso
logo no início Vamos entrar na minha interface de usuário. Eu vou
usar essa interface de usuário aqui. Essa Camas que eu fiz, eu
vou criar um botão. Eu vou ter dois botões. Vamos deixar o legado. Eu não preciso de um botão
com o Text me. Eu só vou mover
isso para cá. E vou excluir o
componente de texto e apenas renomeá-lo para Fx e renomear o que está
abaixo dele Eu vou
colocá-los lá. Acho que quero, na minha nuvem poder silenciar
a música dessa forma Obviamente, vou usar sprites
reais aqui. Vou definir essas posições. Negativo 4.445
negativo 445, legal. Então, vamos entrar em
meus sprites e pegar esses dois sprites que eu fiz especificamente
para o seguinte Música E acho que o
outro se chamava Sound. Aí está. Vamos
importar esses dois. Certifique-se de que
selecionamos e fazemos a coisa normal que
fazemos quando adicionamos novos sprites Vamos até aqui na
imagem de origem e
garantir que a imagem X arrastada em nosso sprite de som, clique em definir tamanho nativo Então, teremos
que escalar isso acordo com o
resto do jogo. Mas antes de fazermos isso,
vamos adicionar pixels. Vamos adicionar música para que possamos fazer
o mesmo ao mesmo tempo. Então vamos ver como
precisamos mudar isso. Obviamente, isso é um pixel. Precisa ser um
pouco menor. Novamente, isso deve ser bom. Perfeito. Acho que
isso é bom o suficiente. Talvez uma vez seja menor. Sim. Agora o que precisamos fazer é voltar
ao esquema aqui. Vamos apenas
garantir que tenhamos um sistema de eventos,
porque é disso que precisamos para que esses
botões funcionem. Vamos
arrastar esse aqui
e esse aqui embaixo, até que fiquem assim, talvez um pouco para o lado. Na verdade, vou querer
os dois na parte inferior. Eu penso assim. Vamos tocar
a música e movê-la. Temos nossos botões
lá. Na verdade, vou mover os dois
um pouco para cima também. Acho que está
tudo bem por enquanto. Agora, tudo o que preciso fazer é garantir que o
código que eu criei seja executado
quando eu faço esses botões. Então, vamos selecioná-los. E então, ao clicar, vou
arrastar esse objeto do
gerenciador de áudio e escolher
Gerenciador de áudio silenciar S ou X. E então, para música,
vou mudar isso para
silenciar música.
Vamos
ver se funcionam. O que deveria acontecer é na verdade, a última
coisa que vou fazer antes de terminar com isso é voltar
ao Gerenciador de áudio. Vou apenas fazer uma
referência a esses dois botões. Vamos usar o Unity Engine. Vamos criar uma referência
aos meus dois botões, botão
Público X e o outro é
música com maiúscula. Desta vez, tudo o que
vou fazer é dizer, ok, se eu realmente vou
criar algumas cores, vou criar uma
cor chamada Grade out. Tudo o que vou fazer é
dizer, ok,
se você já silenciou a música, então esmaeça a música. Você
pode ver a mudança Vamos continuar
aqui e
digamos que, se a música estiver silenciada.
Em outras palavras, se agora silenciamos o
microfone, o mudo será
configurado para verdadeiro no minuto Em outras palavras,
se tivermos silenciado, vamos definir a
cor da imagem da minha música igual Então, abaixo disso,
vou escrever L. cor da imagem
musical é
igual à cor branca Devo escrever praticamente
o mesmo código abaixo dos
efeitos sonoros aqui Digamos que se o X estiver mudo, cor do ponto X da imagem
é cinza Caso contrário, defina-o como branco. Vamos voltar ao meu jogo então. Abaixo do meu script de
gerenciamento de áudio aqui, eu só preciso criar uma
referência para esses dois Vamos arrastar X para lá
e vamos arrastar músicas como se fosse fazer a
cor de criação ser algo parecido com isso. E veja se podemos ver isso em
ação enquanto jogamos o jogo. Vamos continuar e clicar em Play. E teste esses dois
botões, veja se eles funcionam. Parece que sim. Vou ver se clicamos
na coisa sonora. Não deveríamos ter
nenhum som. Então, vamos silenciar
os dois enquanto eu falo, só para testar se alguma coisa não
está funcionando Parece que o robô ainda
é um problema. E a razão para
isso é porque,
na verdade, estamos desativando isso manualmente Em vez disso, o que vou
fazer é definir o volume
em vez de silenciar Em seguida, ajuste o volume de volta. O que na verdade é muito legal. Na verdade, eu não pensei nisso. Mas vamos
fazer essa mudança rapidamente. Em vez de dizer que silenciar é falso, vou dizer que o
volume é igual a. E então
qual é o volume que eu quero que meu robô
normalmente
tenha, geralmente é 0,01. Então,
vou definir o volume para 0,01. Basta colocar um depois disso Isso é o que você
precisa fazer. Então, o
que será ditado
quando isso for desligado novamente
é que, quando eu tiver, meu ladrilho
será limpo. Então, vamos começar. Em vez de dizer mudo, direi que o volume
é igual a zero Então, na verdade, a última
mudança que você precisa fazer depois de fazer isso é voltar
ao meu jogo. Preciso ler esse
roteiro aqui. E eu preciso
realmente definir isso para zero no início
do jogo. E não mudo desse jeito. Agora, quando eu jogo, eu não deveria ouvir
nenhum ruído de robô Quando eu começo, se eu silenciar o som
e o áudio, isso não deve ser
mais
um problema , pois podemos testar Na verdade, isso
ainda deve estar subindo para 0,01 quando eu toco,
porque fica mudo
quando eu o ouço Devemos ter um robô na
tela agora, o que é perfeito. Você pode ver que está
realmente funcionando. Então, no minuto em que
esse robô realmente for destruído pela nuvem, não haverá
efeitos sonoros sendo reproduzidos. Nada está tocando, o que
é exatamente o que queremos. No minuto em que esse robô
realmente for destruído, devemos ter essa
queda de volta a zero, o que parece que acabou de acontecer. O que é ótimo.
Na verdade, esse é todo o som que precisamos
fazer para o nosso jogo. E agora você pode obviamente mudar isso sempre
que entrar no jogo Você pode selecioná-la se
quiser ativá-la ou desativá-la. Obviamente, ele estará ativado por
padrão. Mas então você pode
simplesmente desligá-lo se quiser,
o que é muito legal. Na verdade, essa é a última coisa. Agora, para completar nosso jogo, a última coisa que
precisamos agora são os retoques finais Mas depois disso, praticamente
terminamos nosso jogo, o que
é muito, muito legal. Obviamente, como eu disse
no próximo vídeo, vamos adicionar
alguns retoques finais para que tudo
pareça um pouco melhor Mas nós praticamente terminamos, então se você acompanhar e
tiver um jogo
parecido com esse , isso é
muito, muito legal. Porque, obviamente, esse é um
jogo
bastante impressionante de se fazer, se você
nunca usou tanto
o Unity antes. Então, bom trabalho em acompanhar. E espero que você esteja bastante
impressionado com seu
jogo e
orgulhoso dele no momento E, como mencionei
no próximo vídeo, abordaremos
apenas alguns retoques finais para deixar nosso jogo
um pouco melhor Mas espero que, como
eu disse, você esteja feliz com o que está
até agora e que tudo esteja funcionando bem no seu jogo ,
assim como no meu Encerraremos este curso
nos próximos dois vídeos
e, no próximo, daremos apenas alguns retoques finais Em seguida, mostrarei
como criar e exportar esse jogo e concluirei
este curso. Obrigado.
18. 17. Toques finais: Olá, e bem-vindo de
volta à Unity para a última aula real em que
desenvolveremos este jogo. Agora, nesta lição,
vamos
adicionar apenas alguns toques
finais Vamos
adicionar duas coisas. Em primeiro lugar,
vamos fazer com que
a câmera acelere com o tempo. Em seguida, também
adicionaremos o pós-processamento,
que é como efeitos visuais em tela cheia, que apenas fazem o jogo
parecer um pouco melhor. É muito difícil de explicar, mas você verá que, depois
de adicioná-la,
começando pela original
, antes de fazer isso,
vou
realmente ativar
essa cortina porque a
desativei há
alguns episódios e,
antes que eu a esqueça,
quando tento realmente
criar meu jogo,
acho que fica muito
mais legal com esse fade in começando pela original
, antes de fazer isso, vou
realmente ativar
essa cortina porque a desativei há
alguns episódios e,
antes que eu a esqueça,
quando tento realmente
criar meu jogo, acho que fica muito
mais legal com esse fade Vamos
ver se tudo isso funciona. Então, temos nosso fade
in e nosso áudio e som estão funcionando exatamente como antes
, obviamente Vamos começar com
isso. Aceleração da câmera. Vou usar scripts e vou criar um novo. Vou chamar
isso de aceleração da câmera, a forma como o script
realmente funcionará. Existem várias maneiras de
fazer isso, mas a maneira que vou escolher dará ao jogador
bastante controle sobre a velocidade
da câmera
em determinados pontos. Eu vou ter
uma variável aqui chamada tempo decorrido A cada quadro,
vou incrementar o tempo
decorrido pelo tempo delta do tempo Em outras palavras, o tempo
decorrido aumentará, basicamente será um
contador E se
colocarmos isso em um objeto, eu vou colocá-lo na câmera
principal, por exemplo. Vamos adicionar
meu script aqui
, chamado de aceleração da câmera,
logo na parte inferior. Aí está. De qualquer forma, se apenas observarmos essa variável de tempo
decorrido, vou silenciar a música para que eu possa falar
enquanto ela Vamos rolar para baixo e
ver aqui que temos esse valor
contando para cima, para cima e para cima. Temos um erro logo
no início
que diz que o valor não pode ser nulo, que acho
que
se refere ao tempo decorrido porque
ainda não o inicializamos, que vou descobrir Mas, basicamente, é apenas um cronômetro. Eu só quero
te mostrar o que é. Originalmente, vamos começar
definindo isso como zero, e agora é um cronômetro. O que vamos
fazer em cada quadro é dizer que se o tempo decorrido é maior
que um valor, o que
basicamente significa subir um nível, então vamos
aumentar o nível Velocidades de câmera, vamos
ter uma matriz aqui no topo. Matriz flutuante pública,
serão as velocidades da câmera. Então, teremos
uma matriz próxima a ela, que será vezes. O que vamos dizer
basicamente é que no minuto em que eu
for maior que um tempo, você terá que aumentar a velocidade
da câmera nessa quantidade. Essa variável de tempo
vamos armazenar em outro flutuador
chamado hora atual No minuto em que começarmos
o jogo, no minuto em que isso começar, definiremos a hora atual igual à primeira
vez em nosso tempo. Vai ser vezes zero. Obviamente, a velocidade da câmera será definida como zero. Precisaremos criar uma referência
para a velocidade da minha câmera aqui. Vamos para a câmera pública,
mova-se, chame isso de velocidade da câmera. Em vez disso, roteiro de câmera. Então vamos
dizer roteiro de câmera. A velocidade da câmera é igual
à velocidade zero. Isso nos
permitirá fazer basicamente mudar
a velocidade
da câmera. Na verdade, isso torna a
alteração que fizemos anteriormente, quando separamos a
velocidade da câmera e a velocidade atual, muito útil, porque
agora podemos alterar a velocidade
sem nos preocupar com a velocidade com que a
câmera está realmente se movendo Isso é o quão rápido ele
deveria estar se movendo, certo? Mas isso não significa que
vai começar a se mover se passar algum tempo enquanto
estivermos mortos ou
algo parecido O que é muito,
muito legal agora. Temos um script
aqui que diz definir a hora
atual como zero e definir o script da câmera para
essa velocidade de câmera porque estamos usando a
mesma variável aqui. Na verdade, vou
definir isso para outra variável, chamada de índice. No início, vamos
definir o índice igual a zero, e vamos
definir isso igual ao índice. E então, toda
vez que tivermos um lapso de tempo, vamos
incrementar E vamos dizer se o
tempo decorrido é maior do que os tempos do índice mais Em outras palavras, se
subimos, se já passamos
tempo suficiente para passar para o próximo nível
, a primeira coisa
que faremos é
incrementar o índice. Vamos indexar mais, mais, em outras palavras,
aumentá-lo em um. Então vamos
dizer abaixo disso, na verdade, antes disso Em vez disso, vamos
dizer que o script da câmera é igual
ao índice de velocidade da câmera. E, na verdade, vamos
mover isso para baixo. Basicamente, o que vamos
fazer é
aumentar a velocidade da câmera nessa quantidade Bem, isso vai
permitir fazer a maneira como esse código vai
funcionar, como eu expliquei. Teremos
uma área de lapso de tempo que será
contada a partir de zero Teremos uma
lista das velocidades da câmera e uma lista dos respectivos horários. E teremos uma hora
atual, uma velocidade da câmera
e um índice atual. Na verdade, não
precisamos dessa variável de tempo atual. Não sei por que o criei. Na verdade, posso remover
os dois aqui. Basicamente, tudo o que precisamos
fazer é ter esse flutuador aqui
que diz que o tempo decorrido, velocidade
da câmera, os tempos,
bem como uma referência
ao script e um índice no
índice inicial está definido Definimos a velocidade da nossa câmera
para a original. Então, desde que o tempo decorrido seja
maior do que qualquer coisa, o índice é maior que um Obviamente, no minuto em que
ficarmos sem um aumento,
haverá um erro. Vou adicionar um pequeno
código abaixo dele que diz:
desde que não estejamos no índice máximo e no minuto em que estivermos
no índice máximo, na verdade
vou
destruir completamente o script Mas até lá, vou
incrementar minha coisa toda vez que o tempo decorrido for na verdade, maior do que
o próximo Eles vão aumentar o índice
e então eu vou ajustar a velocidade
da câmera
para o que está aqui embaixo Vou dizer que se o índice
for igual à velocidade da câmera, comprimento, em outras palavras,
se atingirmos o máximo, o índice
funcionará desde que seja um a menos. Mas no minuto em que for mais um, em outras palavras, chegarmos
ao máximo, vou deletar
esse script. Isso não vai ser um
problema porque quando
recarregarmos a cena,
ela voltará para lá Mas, basicamente, por
enquanto , porque eu
não preciso mais, direi que destrua o objeto do jogo ponto para acelerar a câmera do componente. Ou melhor, em vez
de destruidor,
direi que o objeto do jogo dot get component camera
speed up habilitado Porque acho que destruir
pode, na verdade, eliminar o objeto
do jogo
em si é igual Basicamente, no minuto em que eu fico sem coisas, simplesmente me desabilito. E, obviamente, eles serão reativados quando
começarmos a cena Mas isso realmente deve
funcionar muito bem em termos de nos dizer o quão rápida a velocidade da
câmera deve ser. Vamos até a câmera principal,
colocá-la na parte inferior e definir a velocidade da minha câmera. Eu vou definir inicialmente
quatro, eu vou definir. Obviamente, isso tem que
ter a mesma duração, digamos, após 2 segundos, após 4 segundos,
após 6 segundos, após 8 segundos,
vou fazer com que seja 123,4 Então,
basicamente, poderemos ver Eles vão escolher o roteiro de movimento da
minha câmera. Vou seguir em
frente e clicar em play. E vamos ver exatamente
como isso funciona. Agora, na verdade, não
precisamos mais dessa variável de câmera. Temos aqui a
velocidade da câmera a ser atribuída a partir daí. Isso não vai
fazer diferença. Vamos em frente e acabemos com zero. Isso realmente não importa. Então vamos continuar
e clicar em play. E antes de realmente clicarmos em play, acabei de perceber que
vamos receber a velocidade
da câmera antes que
qualquer coisa realmente comece. Só queremos que esse vazio seja chamado quando realmente
começarmos o jogo Vamos começar com o vazio público. E,
na verdade, será chamado pelo script do gerenciador de inicialização
que
criamos há algum tempo. Vamos voltar aqui
e criar uma câmera pública para acelerar a velocidade. Vamos até aqui
e dizer que a velocidade da câmera começa. Caso contrário, a câmera
começará a se mover antes de começarmos o jogo.
Vamos voltar aqui. Vamos ver meu roteiro inicial
aqui até o limite. Vamos garantir que adicionemos meu script de aceleração de
câmera lá. Vamos ver se funciona. Agora, o que deve acontecer é que
devemos ter 4 segundos, o primeiro segundo, ou
melhor, 8 segundos, e quatro velocidades diferentes,
dependendo de quanto tempo estamos jogando o T,
começamos
o jogo, ainda devemos ter a câmera se movendo, o que espero que
aconteça Ótimo, vou silenciar
isso para poder explicar. Então, no minuto em que
começo a passar, estou passando um,
2 segundos depois. Então eu deveria me mudar às duas. Parece que diz que o índice está fora dos limites, o raio Vamos ver
qual é o problema. Aparentemente, o índice está
fora do raio limite, o que significa que estamos
tentando referenciar algo que
não existe aqui Vamos ver como
codificamos isso aqui. Na verdade,
isso é igual ao comprimento
da câmera menos um O índice é, na verdade, um a
menos que o comprimento da câmera se
o comprimento da câmera for três. Quando o índice for dois, não
haverá nenhum terceiro elemento aqui.
Isso precisa ser menos um Na verdade, acabei de
perceber que também acho que não codificamos em nenhum lugar o fato de que o script da
câmera deveria na verdade, ser a velocidade que
programamos aqui Vamos supor
que, no minuto em que
começarmos , ele assinará
bem. Mas toda
vez que fazemos isso, queremos ter certeza de
que estamos passando,
estamos nos certificando de
que a velocidade da câmera seja, na verdade, a velocidade máxima da
câmera Para fazer isso, realmente temos que
levar em consideração a morte. Vamos criar uma referência à saúde pública do
meu jogador, chame-a de Player. Então, vamos até
aqui e
diremos que todo esse código
aqui só será executado
se o jogador
não estiver morto é igual Vamos voltar aqui. E então vamos até a velocidade da minha
câmera e digamos que a velocidade script
da câmera é
igual à velocidade da câmera do
script da câmera. Na verdade, isso deve fazer que tudo funcione
perfeitamente bem. Agora vamos testar novamente,
obviamente porque você se
depara com bugs como esse toda vez que está desenvolvendo um jogo. Obviamente, agora esperamos ter consertado tudo. Vamos voltar. Vamos ver, a forma como
codificamos isso realmente leva em conta que não
precisamos de um tempo aqui porque nunca estamos realmente nos
referindo a esse tempo Estamos nos referindo apenas ao tempo que esses segundos tenham passado. Então, vamos em frente e, na verdade,
fazer mais uma mudança. Antes de fazermos isso,
queremos apenas considerar o tempo,
decorrer o minuto em que o jogo realmente
começou a Vamos
dizer que, se precisarmos outro lingote, diga que começou Digamos que, se começarmos,
em outras palavras, se estivermos realmente
jogando o jogo que começou, só
se tornará realidade aqui. Vamos dar
uma olhada no novo código. existem alguns erros Na verdade, existem alguns erros aqui que
precisamos corrigir, mas todos eles devem ser corrigidos. Agora vamos voltar ao nosso jogo. Vamos dar uma olhada em todas as coisas
diferentes que
temos aqui em nosso novo roteiro. Devemos ter esse lapso de tempo zero até o jogo começar E então devemos ser capazes
de ver a velocidade da câmera. Quase me esqueci de
atribuir a saúde do jogador. Vamos voltar aqui e
atribuir isso ao meu player,
o clique duplo, ou
melhor, um único clique. Vamos ver se tudo
funciona agora. Begun está definido como falso,
exatamente como deveria ser. Vamos desativar o. Som. Vamos ver se não
temos tempo decorrido no
minuto em que passamos.
O tempo começa a contar. Perfeito, atualmente temos 1 minuto, 4 segundos se passaram. Devemos acelerar agora para dois. Parece que não
estamos acelerando novamente. Vamos voltar ao roteiro. A velocidade da câmera está
atualmente definida como um. Agora, a velocidade da câmera não está sendo atualizada, talvez a variável morta
seja o problema. Vamos ver,
porque não acho que nosso índice esteja realmente
sendo atualizado. Sim, não é. Nosso índice está em zero. Vamos voltar e ver
se podemos consertá-lo. A terceira vez é o charme. Acho que morrer, na verdade, não é tudo. Sim, está morto o lingote. Vamos seguir em frente e
mudar isso está morto. Na verdade,
acho que é um sprite. Sim, é claramente
por isso que não estava funcionando. Agora, se voltarmos ao
meu jogo aqui, poderemos
ver a velocidade da câmera aumentar à medida que avançamos. Vamos clicar em play para testar se realmente funciona. Devemos começar com o
tempo decorrido de zero. Na verdade, o tempo não deve ser
contado até começarmos a jogar, que parece ser o que temos. Vamos começar
o jogo. E agora começamos
com uma velocidade de um. E parece que
isso vai ficar em um, talvez seja o aumento de dois,
não o aumento de três, e
o aumento de saída para quatro. Obviamente, podemos ver
o jogo acelerar drasticamente, o
que é muito legal À medida que aceleramos a
câmera, essas coisas se distanciam cada vez mais. Na verdade, eles não
se afastam mais, mas ficam mais frequentes. Mas espero que isso
faça com que o jogo pareça um pouco mais escalável Obviamente, é um pouco mais difícil
acompanhar a câmera
e, se você não o
fizer, obviamente morrerá. O que você
realmente precisará fazer é editar o que você
quer que eles sejam. Vou configurá-lo como 1.8 no início,
assim como o tínhamos. Então eu acho que
quero definir para 2.2 0.4. Então, basicamente vou incrementar bastante
isso Vou fazer com que dez deles
digam que de 2,4 podemos ir para 2,6 e depois 2,62 0,82 0,83 e então
vamos para 3,23 pontos, 4,3 0,6 E acho que
deveria ser no máximo 3,6 depois de jogar
por um bom tempo Então, vamos definir o tempo decorrido. Só deve mudar depois de
cerca de 20 segundos, 30 segundos, 40
segundos, 50 segundos. E eu vou
dizer que você atinge velocidade
máxima depois de jogar
por cerca de 100 segundos. E quero dizer, você não precisa
usar esses valores exatos. Esses podem ser
os que eu vou usar, mas acho que
devem funcionar muito bem para a forma como
jogamos o jogo até agora. Então, vamos ver se
isso realmente
funciona e parece natural
no começo. No mínimo, vamos
desativar o som. Veja
que temos o mesmo tipo de velocidade com a qual sempre nos acostumamos. E então, em 20
segundos, devemos ter a velocidade aumentando e
aumentando, o que é legal. Então esse é o primeiro tipo
de passo que precisamos dar até o ajuste final que precisamos dar
ao nosso jogo A segunda coisa é adiar. Felizmente, espero que seja
muito menos tipo de codificação
e muito Vamos começar criando
um objeto de pós-processamento. E vamos usar o Gerenciador de
Pacotes do Windows agora mesmo. Vamos encontrar
esse pacote de postagem. O que você precisa fazer é
entrar em pacotes que você possa
ter no conjunto de projetos. Então, vamos ao registro do
Unity e localizaremos esse objeto
de pós-processamento. Em seguida, você clicará
em Instalar. Isso
instalará essa pilha ou pacote em seu projeto Vai dizer instalando.
Pode demorar um pouco, dependendo da velocidade
do seu computador e/ou Wi-Fi. Mas depois disso, a instalação é
concluída. Você pode ver que
esse pop-up aparecerá aqui, então tudo deve ser carregado. Agora, o que essa
pilha de adiamento permite eu realmente me livre da cortina
do editor Estamos usando esse
botão. Isso não afetará o
jogo, o que é legal. Eu deveria ter feito isso antes. De qualquer forma, o que isso realmente nos
permitirá fazer é basicamente adicionar
efeitos visuais aos nossos jogos. Vamos primeiro ver
esse objeto de adiamento que
temos aqui A primeira coisa que precisamos
fazer é ir até minha câmera e eu preciso adicionar uma camada
de pós-processamento. Vamos digitar postagens, podemos ver se você tem todas
essas coisas novas. Pode demorar um pouco
para carregar todos eles, mas temos uma depuração com a
qual não vamos nos
preocupar Temos uma camada,
temos um volume. Apenas espere que isso recarregue. E então vamos voltar aqui e adicionar uma camada à câmera. Agora você pode deixar
praticamente todas essas configurações como estão, exceto que obviamente
precisa escolher
uma camada a ser afetada
pelo adiamento, que é como nossos efeitos
especiais Vou passar por
cima e criar uma nova camada, que é uma etiqueta Vou criar uma nova camada, vou
chamá-la de pós-processo. Vá até minha postagem e
verifique se está nessa camada. Vou até minha câmera
principal e
vou configurar minha câmera principal para ser aquela camada de pós-processamento que deve ter
tudo funcionando. Vou deixar o
resto como está por enquanto. Agora vou até meu objeto de
pós-processamento aqui e vou
adicionar um volume de pós-processamento. Isso vai me
permitir basicamente editar meu jogo. Na verdade, vou desativar
isso agora para que eu possa ver,
porque você só pode ver o
pós-processamento no jogo Eu vou poder adicionar um monte de efeitos especiais muito
legais, você pode brincar com eles. Eu não sou o melhor em
usar isso, para ser honesto. Isso é basicamente
editar seu núcleo. Você vai ter
um monte de configurações
diferentes
e, obviamente, quanto melhor você for
na edição
e adiamento de fotos , acho que na edição
de vídeo, tudo isso
vai estar ligado a isso Eu tenho alguns truques
que uso nos meus jogos, mas não sou o mais
experiente nisso. De qualquer forma, é muito
fácil de aprender, assim como os sistemas de partículas, você precisa começar
criando um novo perfil Então você pode começar a
adicionar efeitos. Vamos usar o Unity e
vamos adicionar flores. Esse é o
efeito favorito da maioria das pessoas. Agora, antes de
podermos ver o
efeito disso, teremos que
verificar se essa é uma caixa global. Então você pode ver
como vai
aumentar a intensidade
da floração. Você pode ver que o jogo
fica brilhante, obviamente, não queremos
que seja assim. Mas você pode ver se
você tem algo como zero ou se tem algo como 0,30 0,5 par Isso faz com que o jogo pareça um
pouco melhor. Pode não ser muito fácil ver
a qualidade do vídeo,
mas, obviamente, ao
chegar a 0,7 ou 0,8, você pode ver o jogo
ganhar vida um pouco. Eu quero definir o meu 20,8,
que é bem alto, mas vou
deixá-lo lá por enquanto Vou diminuir
um pouco
o limite , ou melhor,
aumentá-lo Você pode ver que, à medida que eu
aumento a intensidade, algumas coisas são afetadas,
mas acho
que isso parece muito legal por enquanto. Um limite bastante alto.
Mas então eu também vou ter um Bloom
decentemente alto Na verdade, vamos configurá-lo para dois, apenas para testar se ele está realmente fazendo alguma coisa. Você pode
clicar nele para ligar e desligar. Meu limite pode
ser um pouco alto, definido em 1,2 Agora você pode ver uma
pequena diferença Vou deixar as coisas
assim por enquanto. Vou adicionar um novo efeito. A próxima coisa que vou
acrescentar será uma vinheta ou uma vinheta Não tenho certeza, isso é apenas um
escurecimento nas bordas. Então, vou adicionar um
pouquinho nas laterais, só para deixar meu
jogo um pouco mais emoldurado Depois disso, vou
adicionar um pouco de gradação de cores. Essa é uma pergunta incrivelmente
complicada. Normalmente não uso
muito isso em meus jogos, mas vou definir a faixa de
baixa definição porque parece que estou preferindo isso Então eu vou
seguir em frente e,
obviamente, posso mudar minha temperatura, o que eu
realmente não vou fazer. Deixe isso assim por enquanto. Talvez eu faça -0,1 só para ver se faz
alguma diferença Você pode ver uma pequena
diferença, mas vou fazer com que
seja 0,2. E,
obviamente, posso adicionar um
filtro de cores se eu quiser. Eu realmente não quero
fazer isso, para ser honesto. Mas se eu quisesse, eu poderia
adicionar um filtro, poderia deixar o jogo um pouco
mais sombrio se eu quisesse, mas vou deixar
isso de fora por enquanto Então você também pode alterar
coisas como o brilho,
obviamente, como
mencionei, você pode. Vou tornar o jogo um mais brilhante e,
na verdade, vou
editar o contraste apenas um
pouco do meu jogo. Faça com que seja menos dois
ou menos três. Só para deixar as coisas mais claras menos cinco deve ser bom Esses são os três efeitos
que eu usei até agora. Na verdade, existem
vários aqui que você pode usar, dependendo do que
deseja para o seu jogo. Você pode adicionar
grãos, por exemplo. Talvez você possa ver
o que isso faz. Obviamente, esse não é o
efeito que pretendo, mas se você quisesse, você poderia. Acho que grãos muito grandes podem parecer legais, dependendo do estilo
que você escolher se estiver criando um jogo retrô Mas eu não vou fazer nada
além do que eu tenho até agora. Você deve ser capaz de ver isso vigor, você pode
ver a diferença. E faça com que o jogo pareça, na minha opinião,
um pouco melhor. Na verdade, vou aumentar um pouco
a flor. Vou fazer com que minha
gradação de cores seja um pouco menor. Eu realmente não
quero que meu brilho seja tão eficaz quanto era. Na verdade, não tenho certeza se a gradação de cores
é uma boa mudança Na verdade, eu poderia
excluir isso completamente. Mas, como eu disse, você pode contorná-los o
quanto quiser. E agora você pode ver que,
se eu
reativar minha cortina
e jogar meu jogo, agora
posso ver qual é o meu jogo Sky Miner
finalizado E essa é a plataforma
intermediária que criamos
nas últimas semanas ou há quanto tempo você está
fazendo o curso. Podemos ver, obviamente, tudo parece um pouco melhor agora E então, quando
entramos, as coisas entram. E podemos ver esse jogo em
pleno desenvolvimento concluído, o que é muito legal, especialmente se esse for
um dos primeiros jogos que
você criou no Unity. Parece que eu morri. Esse é um dos primeiros jogos que
você já fez em Unity. É muito impressionante ter sido capaz de
fazer tudo isso. Se você fez
tudo e está tudo funcionando como menos, então é muito
bom poder
acompanhar desse jeito No próximo vídeo,
vamos
criar e
exportar esse jogo E isso nem é
realmente um vídeo. Sou só eu mostrando
como
construí-lo em um projeto para que você
possa jogá-lo corretamente. Mas, por enquanto, praticamente
terminamos tudo
para este jogo. Se você acompanhar
e tudo funcionando como
menos, espero que esteja E espero que você
tenha aprendido
bastante ao criar
este jogo. E talvez você possa até
transformá-lo em um jogo que queira lançar
para celular ou
PC ou algo parecido Mas, por enquanto, ótimo trabalho em concluir
todo o curso. E
parabéns por criar seu jogo. Obrigada.
19. 18. Construção e exportação: Olá, e bem-vindo de
volta à Unity. Agora estamos praticamente terminados. Bem, na verdade, terminamos
totalmente nosso jogo de
plataforma intermediária sky miner Nos últimos tempos,
passamos incontáveis
horas ou minutos, dependendo da rapidez com que você
conseguiu assistir a
todos os vídeos, criando o
que
temos à nossa frente . Na
verdade, é muito,
muito legal termos conseguido
criar um jogo como esse,
provavelmente em pouco Como eu disse no último vídeo, parabéns por ter
chegado até aqui. E se você conseguiu
chegar ao final
do
curso desta forma e seu jogo está funcionando exatamente como meu está funcionando, então ótimo trabalho. E isso é realmente
muito impressionante, especialmente se este for um dos seus primeiros jogos em que você domina o Unity. Mas mesmo que não seja
para criar um jogo Unity, qualquer jogo em geral é
um prêmio por si só,
mas especialmente aquele com
sprites, música e escala,
dificuldade e geração aleatória de dificuldade e Tudo isso é uma conquista muito
legal. Muito bem feito. Agora ainda precisamos ser
capazes de criar o jogo porque não
podemos dizer exatamente,
sim, dar uma olhada no meu
jogo e depois
carregar o Unity toda vez que
quisermos mostrá-lo a alguém. Portanto, precisamos ser capazes de
exportar esse jogo para um arquivo
para que não precisemos jogá-lo no editor. Esse será o
propósito deste vídeo. Vou mostrar rapidamente como
exportar seu jogo e jogá-lo em uma enorme janela de tela
cheia. E então vou
concluir o curso Enquanto estou jogando o
jogo em segundo plano,
vamos até
o topo aqui e clique em Configurações de criação de arquivos. E é aqui
que você editará todo
o
aspecto de construção do jogo. Agora, não vou
entrar em muitos detalhes sobre cada um
deles, porque se você clicar em Play A Sets, poderá ver
quantos realmente existem. Há tudo isso.
Há gerenciamento predefinido Bem, na verdade, não
se esqueça disso. Há um ícone que
você pode alterar aqui, há uma resolução,
há uma imagem inicial, que é meio que reproduzida
no início do jogo Depois, há
várias outras configurações com as quais você realmente não deve
mexer muito, especialmente se você realmente não
sabe o que está fazendo Porque, bem, eles
podem quebrar o jogo. Mas, por enquanto, tudo
o que vamos fazer é deixar esses padrões. Esta é a plataforma
aqui para a qual
vamos construir. Se você quiser mudar
isso para um jogo Andro, basta
instalar o módulo e clicar em mudar de plataforma. E faz
muitas coisas por você. Mas vamos criar
nosso jogo para um computador. não vamos nos preocupar com nenhuma enquanto, não vamos nos preocupar com nenhuma
das cenas desses jogadores. Mas, obviamente, você pode
mudar tudo isso. Eles serão
incorporados ao aplicativo. Assim, você pode alterar o
nome da sua empresa, o nome do produto. Eu posso mudar para o Sky
Miner se eu quiser. E eu posso mudar o ícone, o cursor e
praticamente todo o resto aqui. Como eu disse, não filtre
muito com essas outras configurações, a menos que você saiba o que está
fazendo ou tenha pesquisado no Google Mas esses
aqui, você pode fazer o que quiser. Você pode alterar o ícone. Você
pode alterar a resolução. E você também pode alterar
a imagem inicial,
que, como eu disse, se clicarmos em Visualizar,
podemos vê-la na verdade É uma imagem que o
Unity exibe quando você inicia um jogo como esse, com a
qual estou realmente feliz. Acho que está tudo bem por enquanto. Então, vou deixar
essas configurações padrão e
começar a criar meu jogo. Nós o construímos para 64 bits e
eu vou clicar em Construir. Bill vai
abrir o Explorador de Arquivos. Eu posso escolher onde
colocar meu jogo. Agora esta é a pasta
onde está todo o meu projeto, então vou
criar uma nova pasta dentro dessa chamada que ele cria. E vou clicar
duas vezes nela e usá-la como uma pasta
para criar meu jogo. E isso
iniciará todo esse processo de construção do meu jogo inteiro. Agora, isso leva algum tempo, especialmente
dependendo da velocidade do seu computador. Mas, em geral, esse é um processo
bastante intensivo. Espere isso, deve
levar de 1 a 2 minutos, dependendo do tamanho do
seu projeto. Para mim, pode não demorar muito porque
não é um jogo muito grande. Mas, dependendo, como eu
disse, do seu projeto e resto e também de todas as nossas postagens que adicionamos, compilação pode
demorar um pouco Sente-se aqui e não
toque muito no seu computador
, pois ele está executando vários processos no momento. Agora, depois de um tempo, a
mente demorou 65 segundos. Você deve ter esse
arquivo aqui, que é criado com
o nome do seu projeto. E este é, na verdade o arquivo executável
que você pode usar para executar seu jogo se você
for até aqui para construir Se clicarmos duas vezes nesse arquivo, na verdade vamos
carregar nosso jogo. Agora, antes de fazer isso,
eu só quero dizer que na primeira
vez que você carrega o jogo, você pode ter alguns problemas de
proporção Por exemplo, na verdade, se
eu fosse carregar isso agora, tenho quase
certeza de que
me deixaria testá-lo e ver. Porque essa é a última
coisa que precisamos corrigir para o nosso jogo. E com
certeza, aí está. Temos algumas coisas
que não estão exatamente onde deveriam estar.
Vamos entrar no jogo. E a forma como vamos
corrigir isso é escolhendo um aspecto
aqui, 1920 por 1080 E vou me livrar da minha cortina só
para poder ver as coisas Isso vai me permitir
redimensionar tudo e movê-lo, então deve ter a
orientação exata que eu quero Vou movê-los
para o lado desse jeito. Isso deve ser bom. mover essa nuvem para lá. Na verdade, acho que talvez eu
também precise aumentar o spawn a
tempo para começar Em vez disso, vou fazer
20. Agora, obviamente, também preciso aumentar o tamanho
deles. Os corações e os
diamantes
agora têm o tamanho errado em pixels Vamos continuar e
ampliá-los um pouco. Vamos ver onde os
temos. Dependendo do seu
computador e do
quanto você seguiu,
exatamente o que eu fiz. Você pode ou não
ter esse problema, eu não tenha com seu computador talvez
eu não tenha com seu computador. Realmente depende. Mas, como eu disse, se
você for ao jogo e alterar essa
configuração aqui, poderá criar o jogo em quatro resoluções
diferentes Estou construindo para 1920
por 1080 no momento. Deixe-me
ter certeza de recitar isso corretamente, apenas para ter
uma visão geral Não está nem perto. Vamos recuar um
pouco mais. Vamos ver. Eu diria que isso é muito bom. Vamos
colocar isso de volta onde estava, aqui em cima. Coloque isso aqui também. E então vamos para o meu balcão. Mova-o para lá e
aumente um pouco também. Sobre isso deve ser bom. Agora. Obviamente, também teremos que testar
nossas animações de interface de usuário,
já que as movemos Então, vamos ver como eles se parecem. Fade in, sim, obviamente
agora estão nas posições erradas, então teremos que
definir as posições iniciais
lá fora e lá fora E então, as
posições de enfraquecimento agora
terão que estar aqui E aqui deve
ser bom por enquanto. Vamos apenas garantir que
temos as mesmas configurações, 880 e menos 772
para a estática, que devemos poder
ver se jogarmos E então, fora da vista realmente não
importa, mas eles precisam estar
fora de vista, obviamente. Vamos seguir em frente e
movê-los também. Agora, esse processo de escalar o
jogo leva algum tempo. Há uma chance de
terminarmos aqui, há uma
chance de não. Mas a única maneira de fazer isso
é construí-lo, executá-lo novamente e testá-lo para ver se temos outros problemas ou
qualquer
outra coisa que precisemos corrigir. Vamos ver, agora vamos carregá-lo. Na verdade, está
muito bom até agora. Podemos clicar nesses botões e tudo parece
estar funcionando. Meu driver gráfico
acha que é um jogo, o que eu acho que é.
Você pode ver lá. Na verdade, tudo
parece estar funcionando bem. No meu caso, a
única coisa que preciso mudar é essa configuração, e o resto do meu
jogo está realmente funcionando bem, o que
é muito legal. Como eu disse, você pode ser
diferente dependendo de quanto você mudou sua proporção e do quanto você acompanhou. Mas é muito legal
que esse tipo de jogo seja tão
fácil de montar Quero dizer, obviamente não é fácil e quanto mais
você codifica, mais difícil, mais fácil fica. Mas ser capaz de fazer algo
assim sem ser desenvolvedor
muito experiente é
muito legal, na minha opinião. Eu só quero dizer um enorme. Obrigado por
apoiar meu curso, por comprá-lo e
por criar este jogo. E espero que você esteja realmente feliz com o que
conseguiu fazer e que tenha aprendido bastante durante todo o processo. qualquer momento, se
precisar de ajuda
com qualquer coisa relacionada a bugs ou problemas com
seu jogo,
você pode usar qualquer forma
de discussão
nesta página do curso ou
deixá-la em uma análise, seja o que for que você queira fazer. uma
vez, muito obrigado por adquirir este curso e espero
que você esteja realmente feliz com o que
conseguiu fazer. E não há um próximo vídeo, então não poderei dizer
o que faremos a seguir, mas espero que, se
você decidir desenvolver jogos como hobby ou
até mesmo como carreira, consiga criar algo
muito, muito legal. Obrigado novamente por
comprar este curso, e eu realmente espero que você
não tenha gostado. Felicidades.